{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %load windows_environment.py\n",
    "import sys\n",
    "\n",
    "sys.path.insert(0,\"E:\\\\sympy\")\n",
    "sys.path.append(\"E:\\\\packaging_tutorial\\\\src\")\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 1\n",
    "\n",
    "from sympy.calculus.util import *\n",
    "from sympy.abc import *\n",
    "\n",
    "%aimport sympy\n",
    "from sympy import *\n",
    "\n",
    "%aimport basic_package.utils\n",
    "from basic_package.utils import *\n",
    "\n",
    "%aimport excel_function_package.chi_square_test\n",
    "from excel_function_package.chi_square_test import *\n",
    "\n",
    "%aimport function_calculator_package.extreme_points\n",
    "from function_calculator_package.extreme_points import *\n",
    "\n",
    "%aimport quadratic_function.utils\n",
    "from quadratic_function.utils import *\n",
    "\n",
    "%aimport quadratic_function.quadraticfunction\n",
    "from quadratic_function.quadraticfunction import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "%aimport quadratic_function.hyperbola\n",
    "from quadratic_function.hyperbola import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport excel_function_package.data\n",
    "from excel_function_package.data import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9de292db",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9b6fc450",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(solveset(x**2-1,x,Reals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "3af24167",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function function_range in module sympy.calculus.util:\n",
      "\n",
      "function_range(f, symbol, domain)\n",
      "    Finds the range of a function in a given domain.\n",
      "    This method is limited by the ability to determine the singularities and\n",
      "    determine limits.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    f : :py:class:`~.Expr`\n",
      "        The concerned function.\n",
      "    symbol : :py:class:`~.Symbol`\n",
      "        The variable for which the range of function is to be determined.\n",
      "    domain : :py:class:`~.Interval`\n",
      "        The domain under which the range of the function has to be found.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan\n",
      "    >>> from sympy.calculus.util import function_range\n",
      "    >>> x = Symbol('x')\n",
      "    >>> function_range(sin(x), x, Interval(0, 2*pi))\n",
      "    Interval(-1, 1)\n",
      "    >>> function_range(tan(x), x, Interval(-pi/2, pi/2))\n",
      "    Interval(-oo, oo)\n",
      "    >>> function_range(1/x, x, S.Reals)\n",
      "    Union(Interval.open(-oo, 0), Interval.open(0, oo))\n",
      "    >>> function_range(exp(x), x, S.Reals)\n",
      "    Interval.open(0, oo)\n",
      "    >>> function_range(log(x), x, S.Reals)\n",
      "    Interval(-oo, oo)\n",
      "    >>> function_range(sqrt(x), x, Interval(-5, 9))\n",
      "    Interval(0, 3)\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    :py:class:`~.Interval`\n",
      "        Union of all ranges for all intervals under domain where function is\n",
      "        continuous.\n",
      "    \n",
      "    Raises\n",
      "    ======\n",
      "    \n",
      "    NotImplementedError\n",
      "        If any of the intervals, in the given domain, for which function\n",
      "        is continuous are not finite or real,\n",
      "        OR if the critical points of the function on the domain cannot be found.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(function_range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "828a2739",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(hyperbola_{dummy} + 1\\right)^{3} \\left(hyperbola_{dummy} + 2\\right) \\left(hyperbola_{dummy}^{2} + 2 hyperbola_{dummy} + 2\\right) \\left(hyperbola_{dummy}^{4} + 4 hyperbola_{dummy}^{3} + 6 hyperbola_{dummy}^{2} + 4 hyperbola_{dummy} + 2\\right)$"
      ],
      "text/plain": [
       "(_hyperbola_dummy + 1)**3*(_hyperbola_dummy + 2)*(_hyperbola_dummy**2 + 2*_hyperbola_dummy + 2)*(_hyperbola_dummy**4 + 4*_hyperbola_dummy**3 + 6*_hyperbola_dummy**2 + 4*_hyperbola_dummy + 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(expand(Sum((1+x)**n,(n,3,10)).doit()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cc880b7",
   "metadata": {},
   "source": [
    "# 2023-2024学年度上学期期末考试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=FiniteSet(-5,-2,0,1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-5, -2, 0, 1, 4\\right\\}$"
      ],
      "text/plain": [
       "{-5, -2, 0, 1, 4}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=solveset(2**x>1/S(8),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-3, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval.open(-3, oo)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-2, 0, 1, 4\\right\\}$"
      ],
      "text/plain": [
       "{-2, 0, 1, 4}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq=Eq((2-a*I)*b+1,4*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b \\left(- i a + 2\\right) + 1 = 4 i$"
      ],
      "text/plain": [
       "Eq(b*(-I*a + 2) + 1, 4*I)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - i a b + 2 b + 1 = 4 i$"
      ],
      "text/plain": [
       "Eq(-I*a*b + 2*b + 1, 4*I)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(eq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 5$"
      ],
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(13**2-12**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1984 \\pi}{3}$"
      ],
      "text/plain": [
       "1984*pi/3"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi/3*8**2*(3*13-8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle hyperbola_{dummy}^{7} - 7 hyperbola_{dummy}^{6} hyperbola_{dummy}^{2} + 21 hyperbola_{dummy}^{5} hyperbola_{dummy}^{4} - 35 hyperbola_{dummy}^{4} hyperbola_{dummy}^{6} + 35 hyperbola_{dummy}^{3} hyperbola_{dummy}^{8} - 21 hyperbola_{dummy}^{2} hyperbola_{dummy}^{10} + 7 hyperbola_{dummy}^{12} hyperbola_{dummy} - hyperbola_{dummy}^{14}$"
      ],
      "text/plain": [
       "_hyperbola_dummy**7 - 7*_hyperbola_dummy**6*_hyperbola_dummy**2 + 21*_hyperbola_dummy**5*_hyperbola_dummy**4 - 35*_hyperbola_dummy**4*_hyperbola_dummy**6 + 35*_hyperbola_dummy**3*_hyperbola_dummy**8 - 21*_hyperbola_dummy**2*_hyperbola_dummy**10 + 7*_hyperbola_dummy**12*_hyperbola_dummy - _hyperbola_dummy**14"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((x-y**2)**7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C=symbols(\"A,B,C\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=tan(B)/tan(A)+tan(B)/tan(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\frac{1}{\\tan{\\left(C \\right)}} + \\frac{1}{\\tan{\\left(A \\right)}}\\right) \\tan{\\left(B \\right)}$"
      ],
      "text/plain": [
       "(1/tan(C) + 1/tan(A))*tan(B)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trigsimp(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.stats import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function FiniteRV in module sympy.stats.frv_types:\n",
      "\n",
      "FiniteRV(name, density, **kwargs)\n",
      "    Create a Finite Random Variable given a dict representing the density.\n",
      "    \n",
      "    Parameters\n",
      "    ==========\n",
      "    \n",
      "    name : Symbol\n",
      "        Represents name of the random variable.\n",
      "    density : dict\n",
      "        Dictionary containing the pdf of finite distribution\n",
      "    check : bool\n",
      "        If True, it will check whether the given density\n",
      "        integrates to 1 over the given set. If False, it\n",
      "        will not perform this check. Default is False.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy.stats import FiniteRV, P, E\n",
      "    \n",
      "    >>> density = {0: .1, 1: .2, 2: .3, 3: .4}\n",
      "    >>> X = FiniteRV('X', density)\n",
      "    \n",
      "    >>> E(X)\n",
      "    2.00000000000000\n",
      "    >>> P(X >= 2)\n",
      "    0.700000000000000\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    RandomSymbol\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(FiniteRV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=FiniteRV(\"X\",{5:0.04,15:0.14,25:0.16,35:0.22,45:0.2,55:0.16,65:0.08})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 37.0$"
      ],
      "text/plain": [
       "37.0000000000000"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.34$"
      ],
      "text/plain": [
       "0.340000000000000"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(X<=30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_kwargs(*args,**kwargs):\n",
    "    for k,v in kwargs.items():\n",
    "        print(str(k)+\":\"+str(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "move:2\n",
      "scale:3\n"
     ]
    }
   ],
   "source": [
    "check_kwargs(move=2,scale=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "scale:3\n",
      "move:2\n"
     ]
    }
   ],
   "source": [
    "check_kwargs(scale=3,move=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\cos{\\left(2 hyperbola_{dummy} + \\frac{\\pi}{6} \\right)}$"
      ],
      "text/plain": [
       "cos(2*_hyperbola_dummy + pi/6)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_transfer(cos(4*x),x,scale=2,move=-pi/12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(2 hyperbola_{dummy} + \\frac{\\pi}{3} \\right)}$"
      ],
      "text/plain": [
       "sin(2*_hyperbola_dummy + pi/3)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_transfer(cos(4*x),x,scale=2,move=pi/12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(2 hyperbola_{dummy} + \\frac{\\pi}{3} \\right)}$"
      ],
      "text/plain": [
       "sin(2*_hyperbola_dummy + pi/3)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_transfer(cos(4*x),x,move=pi/24,scale=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\cos{\\left(2 hyperbola_{dummy} + \\frac{\\pi}{6} \\right)}$"
      ],
      "text/plain": [
       "cos(2*_hyperbola_dummy + pi/6)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_transfer(cos(4*x),x,move=-pi/24,scale=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*ln(x)-x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - hyperbola_{dummy}^{2} + 2 \\log{\\left(hyperbola_{dummy} \\right)}$"
      ],
      "text/plain": [
       "-_hyperbola_dummy**2 + 2*log(_hyperbola_dummy)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2 \\left(hyperbola_{dummy} - 1\\right) \\left(hyperbola_{dummy} + 1\\right)}{hyperbola_{dummy}}$"
      ],
      "text/plain": [
       "-2*(_hyperbola_dummy - 1)*(_hyperbola_dummy + 1)/_hyperbola_dummy"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -3$"
      ],
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr).subs(x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y = t^{2} - 2 t x + 2 \\log{\\left(t \\right)} - 2 + \\frac{2 x}{t}$"
      ],
      "text/plain": [
       "Eq(y, t**2 - 2*t*x + 2*log(t) - 2 + 2*x/t)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_tangent(expr,x,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x181a1672a10>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,0.2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -1\\right]$"
      ],
      "text/plain": [
       "Interval(-oo, -1)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(expr,x,Interval.open(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{3 \\sqrt{6} m}{4}, \\  \\frac{3 \\sqrt{10} m}{8}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(3*sqrt(6)*m/4, 3*sqrt(10)*m/8)}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([y-(sqrt(15)/9*(x+3*sqrt(6)/8*m)),y-sqrt(15)/3*(x-3*sqrt(6)/8*m)],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Data in module excel_function_package.data:\n",
      "\n",
      "class Data(builtins.list)\n",
      " |  Data(iterable=(), /)\n",
      " |  \n",
      " |  this is a child class of list.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Data\n",
      " |      builtins.list\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __div__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __pow__(self, n)\n",
      " |  \n",
      " |  __radd__ = __add__(self, other)\n",
      " |  \n",
      " |  __rdiv__ = __div__(self, other)\n",
      " |  \n",
      " |  __rmul__ = __mul__(self, other)\n",
      " |  \n",
      " |  __rsub__ = __sub__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  mean(self)\n",
      " |  \n",
      " |  range(self)\n",
      " |  \n",
      " |  variance(self, sample=True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from builtins.list:\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |  \n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |  \n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |  \n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |  \n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |  \n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |  \n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |  \n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |      \n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |  \n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Sort the list in ascending order and return None.\n",
      " |      \n",
      " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
      " |      order of two equal elements is maintained).\n",
      " |      \n",
      " |      If a key function is given, apply it once to each list item and sort them,\n",
      " |      ascending or descending, according to their function values.\n",
      " |      \n",
      " |      The reverse flag can be set to sort in descending order.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from builtins.list:\n",
      " |  \n",
      " |  __class_getitem__(...) from builtins.type\n",
      " |      See PEP 585\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods inherited from builtins.list:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from builtins.list:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=Data([S(1),S(2),3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y=Data([S(2),Rational(22,10),Rational(24,10),Rational(28,10),Rational(31,10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Data' object has no attribute 'power'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m/Volumes/jupyter/11月份一般性草稿.ipynb 单元格 46\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/Volumes/jupyter/11%E6%9C%88%E4%BB%BD%E4%B8%80%E8%88%AC%E6%80%A7%E8%8D%89%E7%A8%BF.ipynb#X63sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39msum\u001b[39m(X\u001b[39m.\u001b[39mpower(\u001b[39m2\u001b[39m))\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'Data' object has no attribute 'power'"
     ]
    }
   ],
   "source": [
    "sum(X.power(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{4}{5}$"
      ],
      "text/plain": [
       "4/5"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(Y.power(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{7 \\sqrt{2}}{10}$"
      ],
      "text/plain": [
       "7*sqrt(2)/10"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(X.power(1)*Y.power(1))/sqrt(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.989949493661167$"
      ],
      "text/plain": [
       "0.989949493661167"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{7}{25}$"
      ],
      "text/plain": [
       "7/25"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(X.power(1)*Y.power(1))/10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{83}{50}$"
      ],
      "text/plain": [
       "83/50"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.mean()-_*X.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{5}{2}$"
      ],
      "text/plain": [
       "5/2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Y.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 \\cdot 3^{n} n}{2} + \\frac{3 \\cdot 3^{n}}{4} - \\frac{3}{4}$"
      ],
      "text/plain": [
       "3*3**n*n/2 + 3*3**n/4 - 3/4"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(summation((n+1)*3**n,(n,1,n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=Ellipse(Point(0,0),a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 + \\frac{y^{2}}{b^{2}} + \\frac{x^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-1 + y**2/b**2 + x**2/a**2"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x+sqrt(a**2-b**2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - k x - k \\sqrt{a^{2} - b^{2}} + y$"
      ],
      "text/plain": [
       "-k*x - k*sqrt(a**2 - b**2) + y"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{4} k^{2} - a^{2} b^{2} k^{2} - a^{2} b^{2} + 2 a^{2} k^{2} x \\sqrt{a^{2} - b^{2}} + x^{2} \\left(a^{2} k^{2} + b^{2}\\right)$"
      ],
      "text/plain": [
       "a**4*k**2 - a**2*b**2*k**2 - a**2*b**2 + 2*a**2*k**2*x*sqrt(a**2 - b**2) + x**2*(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{4} k^{2} - a^{2} b^{2} k^{2} - a^{2} b^{2} + 2 a^{2} k^{2} x \\sqrt{a^{2} - b^{2}} + x^{2} \\left(a^{2} k^{2} + b^{2}\\right)$"
      ],
      "text/plain": [
       "a**4*k**2 - a**2*b**2*k**2 - a**2*b**2 + 2*a**2*k**2*x*sqrt(a**2 - b**2) + x**2*(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,x2=q.roots.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{2} \\left(a^{2} k^{2} - b^{2} k^{2} - b^{2}\\right)}{a^{2} k^{2} + b^{2}}$"
      ],
      "text/plain": [
       "a**2*(a**2*k**2 - b**2*k**2 - b**2)/(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(x1*x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{2 a^{2} k^{2} \\sqrt{a^{2} - b^{2}}}{a^{2} k^{2} + b^{2}}$"
      ],
      "text/plain": [
       "-2*a**2*k**2*sqrt(a**2 - b**2)/(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(x1+x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1y2=simplify(list(solveset(l.equation(x).subs(x,x1),y))[0]*list(solveset(l.equation(x).subs(x,x2),y))[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{b^{4} k^{2}}{a^{2} k^{2} + b^{2}}$"
      ],
      "text/plain": [
       "-b**4*k**2/(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1y2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{2} k^{2} \\cdot \\left(2 a^{2} + 2 a \\sqrt{a^{2} - b^{2}} - b^{2}\\right)}{a^{2} k^{2} + b^{2}}$"
      ],
      "text/plain": [
       "a**2*k**2*(2*a**2 + 2*a*sqrt(a**2 - b**2) - b**2)/(a**2*k**2 + b**2)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(simplify(x1*x2)-a*simplify(x1+x2)+a**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a^{2} \\cdot \\left(2 a^{2} + 2 a \\sqrt{a^{2} - b^{2}} - b^{2}\\right)}{b^{4}}$"
      ],
      "text/plain": [
       "-a**2*(2*a**2 + 2*a*sqrt(a**2 - b**2) - b**2)/b**4"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_/y1y2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{2} \\left(- 2 a^{2} - 2 a \\sqrt{a^{2} - b^{2}} + b^{2}\\right)}{b^{4}}$"
      ],
      "text/plain": [
       "a**2*(-2*a**2 - 2*a*sqrt(a**2 - b**2) + b**2)/b**4"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=Ellipse(Point(0,0),4,2*sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{16} + \\frac{y^{2}}{12} - 1$"
      ],
      "text/plain": [
       "x**2/16 + y**2/12 - 1"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(x-m*y+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle y - \\frac{x}{m} - \\frac{2}{m}$"
      ],
      "text/plain": [
       "y - x/m - 2/m"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 12 m y + y^{2} \\cdot \\left(3 m^{2} + 4\\right) - 36$"
      ],
      "text/plain": [
       "-12*m*y + y**2*(3*m**2 + 4) - 36"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,e,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=x*(exp(-x)+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x \\left(1 + e^{- x}\\right)$"
      ],
      "text/plain": [
       "x*(1 + exp(-x))"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(x - e^{x} - 1\\right) e^{- x}$"
      ],
      "text/plain": [
       "-(x - exp(x) - 1)*exp(-x)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr1=x*exp(-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr2=expr1.subs(x,1/t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{e^{- \\frac{1}{t}}}{t}$"
      ],
      "text/plain": [
       "exp(-1/t)/t"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\left(t - 1\\right) e^{- \\frac{1}{t}}}{t^{3}}$"
      ],
      "text/plain": [
       "-(t - 1)*exp(-1/t)/t**3"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr2,t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRd0lEQVR4nO3deXyU5b3///dkh5AMZJsECCGsSdiEsCQgoAIRqlbraaWLWHu0yjlqi5yeUz22PWp7vuiptS4V1FZL7a8iWvTosSBEZTWIggnIvpMA2bfJvkzu3x9DRkICJpDknuX1fDzmQXLPNXc+czPceXNf93VdFsMwDAEAAMDj+ZldAAAAALoHwQ4AAMBLEOwAAAC8BMEOAADASxDsAAAAvATBDgAAwEsQ7AAAALwEwQ4AAMBLEOwAeD3DMGS328V87AC8HcEOgNerqqqS1WpVVVWV2aUAQI8i2AEAAHgJgh0AAICXINgBAAB4CYIdAACAlyDYAQAAeAmCHQAAgJcg2AEAAHgJgh0AAICXINgBAAB4CYIdAACAlyDYAQAAeAmCHQAAgJcg2AEAAHgJgh0AAICXINgBAAB4CYIdAACAlyDYAQAAeAmCHQAAgJcIMLsAAJ6lodmh6vpmVdU3q7rB+WdVfZOqG776vqahWQ7DkGFIhmGoxZBazn3fYhhqMQwF+PkpONBPwQH+Cg7wU3CAn0ICz3197s+w4ABZ+waqf98g9e8TqL5B/rJYLGYfAgBwWwQ7AJKcAaysplH5lfU6W1GnsxV1zq/PfZ9fUaeS6kY1OlpMqzHQ3yJrn0BZ+3wV9vr3DZItPFi28JBzD+fX0WHBCvSnUwKAbyHYAT6m2dGik6U1OpBfpUMFVTpYYNex4hqdrahTQ3PnQ1u/4ADnIyRAYSHOr8NCAhQWHKi+wf7yt1jk52eRxSL5WSzyO/enxWKRRZKjxVBDs0P1TS1qaHaooblF9U3OPxuaWlR/7spgRV2TKmob1eQw1OQwVFLdqJLqRkk1l6zPYpEiQ4MVaw1WRKBDkvTX7Sc1Ot6m+Ii+io/oo75BnAIBeBfOaoAXK61u0IF8Z3g7kF+lQ4V2HS6sVuMlAlx0WLAGWkM0sH8fxVn7aGD/1q9DFBMe4gxxQQHy8+u9LlHDMFTX5FBFbZPzUdeoytomVdY1qbSmUUX2ehXaG1RYVa8ie4MK7fVqbjFUUt2gkuoGtTTUSpKe/OCQ/ILzXPuNDA3S4Ii+Sojoq8SoUA2LDtXw6H4aFh1K6APgkSyGYRhmFwGgexRV1WvH8TJ9erxUO06U6WhRdYft+gb5a5QtTMlxYUqKDddIWz8N7t9XNmuwggP8e7nq7tfSYqistlGF9noV2ut19Eyx7p07Tne9vEkF9X7KK6tTZV3TJfcRZw3RsOhQDYvqpxEx/TQ6NkyjbWEaEBrUS+8CALqOYAd4sEJ7vT49XqpPj5dpx4lSHS9u3z2ZGBWqpNgwjY51hrjkuDDFD+jbq1fczGa322W1WlVZWanw8HBJUmVdk/LKanW6vFanSmt1vLhGx4qrdbykRmU1jRfdV3RYsEbbwjTKFqbRsf00OjZco21h6hPk+YEYgOcj2AEexDAM7Ttr1z++zNf6vQU6XtI2yFksUnJsuNKGRWrasAhNHRrBFSZ1HOwupaK2UceKa3T8XNA7UlilQ4VVyiur67C9n0UaFt1PKXHhGjMwXCkDw5USF67IfsHd/VYA4JIIdoCbOz/M/WNPvnLLal3PWSzSmIHhSkuM1LRhkZo6NELWvoEmVuueuhrsLqamoVlHiqp1uMAZ9FoHnzgHc7QXGx6icYOtmjDYqnGD+2vcIKsiCNoAehDBDnBDlwpzIYF+unZ0jL4xLk6zRkXL2ocg93W6K9h1xDAMFVc1aF++XfvPnnvk23WipONRu4MH9NGEwf01brBVV8X31/jBVgZqAOg2BDvAjew9U3nJMHfD+DhdOzpGocEEga7oyWB3MdUNzdp/1q49pyu053SlvjxT2WHY8/ezaLQtTBOH9NfEIQM0aUh/JUaFMhEzgMtCsANM1uxo0bq9BXpl2wnl5FW4tocE+um6JOeVOcLclTEj2HWksq5J+85Uas+ZSu3Oq1BOXoXyK+vbtbP2CdTEIf01acgATR46QFfF9+eqHoBOIdgBJqmsbdIbn+fqL1kndfbcL/cgfz/NSXZembsuKYZf5t3EXYJdR/Ir65STW6HsvApl55Zrz+nKdhNFB/hZNGZguCYPjdDkhAFKHTpAMWEhJlUMwJ0R7IBedqKkRn/+5IT+vuu0ahudKyJEhgbp9rQE3Z6WoOgwRlJ2N3cOdhdqcrToYH6Vvsgt185T5dp5sqzDq3oJkX01OSFC04ZFKC0xUvERfei+BUCwA3qDYRjafqxUr2w7oY8PFan1X11SbJj++epEfXPCQIUEMg9aT/GkYNeRMxV12nmyTDtPluvzk2U6VFilC8/ccdYQTUuM0LRhkZqWGMF9eoCPItgBPaixuUXv5pzRK9tO6GBBlWv7dUkxuuvqRE0fHskv317g6cHuQpV1Tfoit1yfnSjTZyfKtOd0hZocbU/l0WHBrqA3fXikhhH0AJ9AsAN6gGEYytxfqGXrDrpGQvYJ9Ne3UwfrRzOGalh0P5Mr9C3eFuwuVNfo0Be55dpxvFSfnihTTl5Fu/WAbeHBmj48SunDnUFv8IC+JlULoCcR7IButv+sXb/5x35lHSuVJEX1C9JdVw/T96bGq39fJqc1g7cHuwvVNzmUk1fhWjd4V255u6A3JKKvpg+PPBf0ori3E/ASBDugmxRV1evpDYe1emeeDEMKCvDTXVcn6l+vGa6wECYRNpOvBbsL1Tc5r+htP1aqrGOl2p1XoeaWtqf+pNgwXT0iSjNGRmlaYgQjsgEPRbADrlB9k0OvbDuh5RuPqubcKNcbxsfpoflJio+gu8sd+Hqwu1B1Q7M+P1mm7cdK9cnREu07a2/zfKC/RZOGDNDVI6J09cgojRtkVYC/n0nVAugKgh1wmQzD0Pt78vXEuoM6U+FcHH78YKt+eWOKpgyNMLk68yxfvly//e1vlZ+frzFjxuiZZ57RzJkzO2y7bds2/fznP9fBgwdVW1urhIQE3XvvvXrwwQddbVauXKkf/ehH7V5bV1enkJDOzeVGsLu0sppGZR0r0bYjJdp6pMT1eW4VHhKgGSOiNGtUtGaOjOL+PMCNca0duAy78yr06/f3a+epcknOxd7/Y/5o3XLVIPn5+e7Iw9WrV2vJkiVavny5ZsyYoZdeekkLFizQ/v37NWTIkHbtQ0NDdf/992v8+PEKDQ3Vtm3bdO+99yo0NFT33HOPq114eLgOHTrU5rWdDXX4ehGhQbpx/EDdOH6gDMPQqdJabTvqDHpZx0pkr2/Wur0FWre3QJI0LDpUs0ZGa9aoKE1LjGRVFMCNcMUO6IKK2kY9/v5+vf3FGUnOka73zh6me2YN454kSdOmTdOkSZO0YsUK17bk5GTdcsstWrZsWaf2ceuttyo0NFR//etfJTmv2C1ZskQVFRWXXRdX7C6fo8XQ7tMV2nq4RFuPFCs7r0KO8+7PC/S3aHJChGaPjtY1o6M12hbGtCqAifhNBHTSJ0dL9G9v7laB3bkKwK0TB+nf549WnLWPyZW5h8bGRu3atUsPPfRQm+0ZGRnKysrq1D6ys7OVlZWl3/zmN222V1dXKyEhQQ6HQ1dddZV+/etfa+LEiRfdT0NDgxoaGlzf2+32i7bFpfn7Oe+3mzRkgH46d6Qq65q0/Vipthwp1pbDxTpdXqftx0u1/Xipnlh3ULbwYM0eFa1rRsdoxogoWfswcAjoTQQ74Gs0NDv01PpD+uPWE5KkYVGh+t1tEzRxyACTK3MvJSUlcjgcstlsbbbbbDYVFBRc8rWDBw9WcXGxmpub9eijj+ruu+92PZeUlKSVK1dq3LhxstvtevbZZzVjxgzt3r1bI0eO7HB/y5Yt02OPPXblbwrtWPsEav7YWM0fGyvDMHSytFZbDhdr8+FiZR0rUaG9QW/uPK03d56Wv59FE+P7u4LemIHhPn2rAtAb6IoFLuFwYZV++kaODuQ7r/h8f9oQ/eKGZLpdO3D27FkNGjRIWVlZSk9Pd23/7//+b/31r3/VwYMHL/raEydOqLq6Wp9++qkeeugh/eEPf9D3vve9Dtu2tLRo0qRJmjVrlp577rkO23R0xS4+Pp6u2B5W3+TQ5yfLtPlQsTYdLtbRouo2z0eHBeuaUdG6NilGV4+MUjjTAAHdjt9OQAcMw9Bfsk5q2bqDamhuUURokJ78p/Gal2L7+hf7qKioKPn7+7e7OldUVNTuKt6FEhMTJUnjxo1TYWGhHn300YsGOz8/P02ZMkVHjhy56P6Cg4MVHMyEu70tJNBfM0dGa+bIaP1C0unyWm0+XKxNh4r1ydESFVc16K1dp/XWrtMK8LMoNWGArkuK0bVJMRoZ049784BuQLADLlBkr9e//32PNh8uliTNHhWt335nvGLCGIV5KUFBQUpNTVVmZqa+9a1vubZnZmbq5ptv7vR+DMNoc7Wto+dzcnI0bty4K6oXPW/wgL76wbQE/WBaghqaHdp5slwbDxZp46EiHSuu0Y4TZdpxokzL1h3UoP59dM3oaM1JjtH04VEKCfQ3u3zAIxHsgPNs2Fegh97+UmU1jQoO8NN/fiNZd6QncCWhk5YuXapFixZp8uTJSk9P18svv6zc3FwtXrxYkvTwww/rzJkzeu211yRJL7zwgoYMGaKkpCRJznntnnrqKT3wwAOufT722GNKS0vTyJEjZbfb9dxzzyknJ0cvvPBC779BXLbgAH/NGBGlGSOi9IsbU5RbWqtNh4u08WCRso6V6kxFnf62I1d/25GrkEA/TR8epeuSYnRdUowG9meAEtBZBDtAUm1js379/gGt+ixXkpQcF65nv3uVRtnCTK7MsyxcuFClpaV6/PHHlZ+fr7Fjx2rt2rVKSEiQJOXn5ys3N9fVvqWlRQ8//LBOnDihgIAADR8+XE888YTuvfdeV5uKigrdc889KigokNVq1cSJE7VlyxZNnTq1198fus+QyL66I32o7kgfqrpGh7YfL9HGg8X6+GCRzlTU6eODRfr4YJEk53Jnc5KdIe+q+AHyZwAGcFEMnoDPK7TX659Xfq59Z+2yWKQfzxymf8sYpeAAuoK8BfPYeQ7DMHSosMoZ7A4U6Yvccp2/rO2AvoG6dnSM5iTbNGtUFOswAxcg2MGn7T9r111/+Vz5lfWKDA3S89+bqOkjoswuC92MYOe5ymsatflwsT46WKTNh4pkr292PRfob9G0xEjNSY7R3GQbazMDItjBh206VKT7/vaFahodGh4dqpU/msovBi9FsPMOTY4W7TpVro8OFOqjA0U6XlLT5vlRtn6ak2zT3GS6bOG7CHbwSX/bcUq/enefHC2G0odF6sXbU2XtS5eOtyLYeafjxdX66ECRPjxQqJ2nytssdRYRGqRrR8doXkqMZo6MZj1b+AyCHXxKS4uhJz84qJe2HJck3TppkJ64dbyCAvxMrgw9iWDn/Sprm7TpcJE+OlCkTRd02QYF+GnG8EjNTbFpTpJNsVamLoL3ItjBZ9Q3OfTg6hyt2+ucQPfBuaP0kzkjmMrEBxDsfEuTo0U7T5brwwOF+vBAoU6V1rZ5fvxgq+Ym2zQ32abkuDDOAfAqBDv4hJLqBt39l53KyatQkL+fnvz2OH1r4mCzy0IvIdj5LsMwdLSoWpkHCvXh/kJl51Xo/N96g/r30bwUZ8ibmhjB1Xt4PIIdvN7Roir9aOXnyiurk7VPoF5elKppwyLNLgu9iGCHVsVVDfr4YKEy9xdp29Fi1Te1uJ4LCw7Q7NHRmpdi07VJMaxlC49EsINXyzpWosV/3SV7fbOGRPTVn380RcOj+5ldFnoZwQ4dqWt06JOjJee6bItUUv3VUnYBfhalD490Xc1j9Qt4CoIdvNb/7T6rpW/mqMlhKDVhgF5elKrIfiwM74sIdvg6LS2GsvMqlLm/UJn7C3SsuO1UKmMHhWtecqzmpXBfHtwbwQ5eacO+Av3L376Qo8XQDePj9LvvTGBRcR9GsENXHS+uPhfyCrUrt7zNfXmDBzjvy8tIidWUoQMU4M99eXAfBDt4nW1HSvTPKz9Xo6NFt04apKe+PUF+TFTq0wh2uBIl1Q36+ECRNuwv0NYjJWpo/uq+vP59A3VdUowyUmyaNSpafYOYLw/mItjBq+w6Vabb//SZ6pocmj8mVn/4/kT+Nw2CHbpNbWOzth4pUeb+Qn10oFDltU2u54ID/DRzZJTmpdg0J9mmKG79gAkIdvAa+85W6rsvf6qq+mbNGhWtP96RquAAul9BsEPPaD63xNmG/YXasL9AeWV1rucsFmlywgBlpMQqY4xNCZGhJlYKX0Kwg1c4WlSthS9tV2lNo6YOjdBf/nmq+gQR6uBEsENPMwxDhwqrtGGfM+TtPWNv8/xoW5iuH2NTxphYjRkYzuAL9BiCHTxeXlmtvvPidhXY6zVukFV/+/E05p9CGwQ79LYzFXX68NyVvE+Pl7VZx3agNUQZY2KVkWLTlMQIBXK7CLoRwQ4erdBer++8uF25ZbUaGdNPq+9NV0RokNllwc0Q7GCmitpGbTxUpA37CrXpULHqmhyu56x9AjUnKUYZYxh8ge5BsIPHKqtp1MKXtutIUbWGRPTVW4vTZQtncW+0R7CDu6hvck6KvH5fgT48UKSymkbXc87BF9HKGGPTnKQY5t3EZSHYwSPZ65v0gz/u0JdnKhUbHqK3FqcrPqKv2WXBTRHs4I4cLYZz8MW+Aq2/YPCFn0WaPDRC15/rsuX8hs4i2MHj1DU6dMerO/T5yXJFhAbpzXvTNSKGZcJwcQQ7uDvDMHSwwDn4Yv2+Au3Pbzv4IiUuXBljbLp+TKySYln5AhdHsINHaWh26O6/7NTWIyUKCwnQqh+naewgq9llwc0R7OBpTpfXukbYfnaiTOeNvdCQiL7KSHGOsE1NGCB/JmDHeQh28BjNjhbd/3q2PthXoD6B/vr/7p6q1IQIs8uCByDYwZOV1TTqowOFWr+vUFuPFLdZ+SIyNEhzk226fqxN04dHsXQiCHbwDC0thn729916+4szCvL306t3TtHVI6PMLgsegmAHb1Hb2Kwth4u1YV+hPjxQKHt9s+u5vkH+umZ0tK4fE6trRsfI2odpn3wRwQ4e4fmPjuh3mYfl72fRih9MUsaYWLNLggch2MEbNTla9NmJMq3fV6AN+wpVYK93PRfob1HasEjXfHnMGOA7CHZwex8fLNRdf9kpw5Ce/KdxWjhliNklwcMQ7ODtDMPQntOVzpC3v1BHi6rbPH9VfH/nCNsxNg2PZrCZNyPYwa2dKKnRN/+wTVX1zbo9bYh+c8s4s0uCByLYwdccK652Db7Izq1o89yImH7KSHGOsB0/2MoIWy9DsIPbqm5o1rde+ERHiqqVmjBAq36cpqAAlt5B1xHs4MsK7fXK3O+cRmX7sVI1nzfENjY8RBljbMpIidW0YSxv5g0IdnBLhmHoX//2hdbtLVBMWLDef+BqxXCPCC4TwQ5wqqxr0ibX8mZFqmn8anmz8JAAzUm2KSPFptmjWd7MUxHs4JaWbzqq//ngkAL9LXrjnnSlJgwwuyR4MIId0F59k0Pbj5WeW96sUCXVFy5vFqWMlFjNSWZ5M09CsIPb2XSoSD9a+bkMQ/p/3xqn709jsASuDMEOuDRHi6Hs3HJtONdle6q01vVc6/JmrfflsbyZeyPYwa2cKq3RTc9vk72+Wd+bGq9lt443uyR4AYId0HmGYehwYfW5EbYF2num7fJmSbFhyhgTq+vH2JQSF87gCzdDsIPbqG1s1q3Ls3SwoEpXxffX6nvTFBzALOq4cgQ74PKdqahT5r4Crd9XqM9Olslx3uCLQf37uAZfTBk6QAEMvjAdwQ5uwTAMPbAqW+/vyVdUP+dgiVgrgyXQPQh2QPcor2nUxweLtGF/gTYfLlZ901fLm/XvG6g5STZljLFp1sho9QniP+ZmINjBLfxp63H95h8HFOBn0ap70jRlKGvAovsQ7IDuV9fo0LajJVq/r0AfHShUeW2T6znn4ItoZYyxaU4Sgy96E8EOptt7plLfWv6JmhyGHr95jO5IH2p2SfAyBDugZzU7WrTzVLnW7ytQ5v5CnS6vcz13/uCLjJRYDYlk8EVPItjBVPVNDt30/DYdKarW9WNsevH2VG7ERbcj2AG9xzAMHcivUuZ+58oX+852MPgixaZ5KbEaO4jBF92NYAdTPfrePq3MOqnosGCtXzJLEaFBZpcEL0SwA8xzurzWGfI6GHwx0BqiuSmsfNGdCHYwzdYjxVr0ymeSpD//aIquHR1jckXwVgQ7wD20Dr7I3F+ozYeLVdfUduWLa5NilJESq9mjo9UvmJUvLgfBDqYor2nU/Ge3qNDeoEVpCfr1LWPNLglejGAHuJ/6Joc+OVqiDfsK9dHBtitfBPn7KX14pOal2DQvxSYbS0p2GsEOvc4wDN33+hda+2WBhkWH6h8PzGRYPHoUwQ5wb44WQzl55dqwr1Ab9hfqRElNm+cnxPc/d1+eTSNj+nFf3iUQ7NDr1uw6rX97a7cC/Cx6519naNxgq9klwcsR7ADPYRiGjhVXa8P+QmXuL1R2bkWb5xMi+2pesjPkpSYwKfKFCHboVXlltVrw7FZVNzTrZxmjdP91I80uCT6AYAd4rqKqen10wHlf3rajJWps/mpS5AF9A8/dl2fTzJHRCuW+PIIdeo+jxdB3X96uz0+Wa3LCAK2+N13+flxOR88j2AHeoaahWVsOFytzf6E+PlSkivMmRQ4K8NOM4ZGalxKruckxivHR+/IIdug1yzcd1f98cEihQf76YMksxUcwSSV6B8EO8D6tkyJnnuuyzS2rbfO8r96XR7BDrzh/dYn/+fZ43TY53uyS4EMIdoB3MwxDhwurlbm/QJkHirQ7r6LN80Mi+mruufvypgz17vvyCHbocY3NLbrx+a06XFit+WNiteL2ST7zPye4B4Id4FuK7PX68ECRPjzQ/r48a59AXTs6WnNTbJo9KlphIYEmVtr9CHboca1dsJGhQcpcOpvVJdDrCHaA76ppaNbWI8X68ECRPj5YpLKar+bLC/S3KG1YpOYm2zQnOUaDB3j+LUIEO/SovLJazfv9ZtU3tejp2ybo1kmDzS4JPohgB0ByDuLLzi1X5oFCfbi/UMeK286XlxwXrnnJMZqTbNO4QVb5eeAAP4IdeoxhGLr7Lzv10cEipQ2L0Kofp9EFC1MQ7AB05HhxtXMqlQOF2nmyTOctY6uYsGDNSY7R3GSbZoyIUkigZ0ykT7BDj1m/r0D3/nWXAv0tWvfTmRoRE2Z2SfBRBDsAX6e8plEbDznvy9t8qFg1jV+tYxsS6KerR0RpbrJN1yXHKCbMfadSIdihR9Q0NGvu05uVX1mv+64drn+/PsnskuDDCHYAuqKh2aFPj5fpowOF+uhAkc5U1LV5fsJgq+Yk2/TNCQM1NCrUpCo75r3jfWGqZz48rPzKesVH9NH917K6hC9Zvny5EhMTFRISotTUVG3duvWibbdt26YZM2YoMjJSffr0UVJSkn7/+9+3a7dmzRqlpKQoODhYKSkpeuedd3ryLQDwccEB/po9KlqP3zxW235+rdb+ZKb+bd4oTYjvL0nafbpST2ce1s5T5eYW2gHW3kC3O5Bv16ufnJQkPf7NseoT5Bn3JeDKrV69WkuWLNHy5cs1Y8YMvfTSS1qwYIH279+vIUOGtGsfGhqq+++/X+PHj1doaKi2bdume++9V6GhobrnnnskSdu3b9fChQv161//Wt/61rf0zjvv6LbbbtO2bds0bdq03n6LAHyMxWJRysBwpQwM1wNzRqrIXq+PDzq7bK8dHW12ee3QFYtu1dJi6NsvZumL3AotGBurFbenml0SetG0adM0adIkrVixwrUtOTlZt9xyi5YtW9apfdx6660KDQ3VX//6V0nSwoULZbfbtW7dOleb+fPna8CAAVq1alWn9klXLABfQVcsutWbO/P0RW6FQoP89aubUswuB72osbFRu3btUkZGRpvtGRkZysrK6tQ+srOzlZWVpdmzZ7u2bd++vd0+r7/++k7vEwB8CV2x6Dal1Q1atu6gJOnBeaMUZ+1jckXoTSUlJXI4HLLZbG2222w2FRQUXPK1gwcPVnFxsZqbm/Xoo4/q7rvvdj1XUFDQ5X02NDSooaHB9b3dbu/KWwEAj8UVO3SbZesOqrKuSclx4bpz+lCzy4FJLpyr0DCMr52/cOvWrdq5c6defPFFPfPMM+26WLu6z2XLlslqtboe8fGsTQzAN3DFDt3i0+Ol+vuu07JYpP/3rbFevcAyOhYVFSV/f/92V9KKioraXXG7UGJioiRp3LhxKiws1KOPPqrvfe97kqTY2Ngu7/Phhx/W0qVLXd/b7XbCHQCfwG9fXLHG5hb94n/3SpK+N3WIJg4ZYHJFMENQUJBSU1OVmZnZZntmZqamT5/e6f0YhtGmGzU9Pb3dPjds2HDJfQYHBys8PLzNAwB8AVfscMX+tO24jhZVKzI0SD9nImKftnTpUi1atEiTJ09Wenq6Xn75ZeXm5mrx4sWSnFfSzpw5o9dee02S9MILL2jIkCFKSnJ+brZt26annnpKDzzwgGufP/3pTzVr1iw9+eSTuvnmm/Xuu+/qww8/1LZt23r/DQKAmyPY4YoUVNbruY+OSJJ+cWOyrH0DTa4IZlq4cKFKS0v1+OOPKz8/X2PHjtXatWuVkJAgScrPz1dubq6rfUtLix5++GGdOHFCAQEBGj58uJ544gnde++9rjbTp0/XG2+8oV/84hf65S9/qeHDh2v16tXMYQcAHWAeO1yRh9/eo1Wf5WlywgC9tTj9a2+SB8zAPHYAfAX32OGyHS2q1ps7T0uSHv5GEqEOAACTEexw2Z5af0iOFkNzk21KTYgwuxwAAHwewQ6XJTu3XB/sK5CfRfqP+aPNLgcAAIhgh8tgGIae/MC5wsQ/TRqsUbYwkysCAAASwQ6XYfPhYn16vExBAX56cN4os8sBAADnEOzQJS0thp784JAk6YfpCRrYn/VgAQBwFwQ7dMl7u8/qQL5dYcEB+tdrRphdDgAAOA/BDp3W0OzQUxucV+sWXzNcA0KDTK4IAACcj2CHTnt9R65Ol9cpJixYP5ox1OxyAADABQh26JTqhmb94eOjkqSfzh2pvkGsRgcAgLsh2KFT/rjluEprGpUYFarbJsebXQ4AAOgAwQ5fq7iqQX/aelyS9LOM0Qr052MDAIA74jc0vtYfPj6imkaHJgy26hvjYs0uBwAAXATBDpeUW1qr1z/LlST9fH6SLBaLyRUBAICLIdjhkn6XeUhNDkMzR0Zp+ogos8sBAACXQLDDRe09U6l3c85Kcl6tAwAA7o1gh4v6n/XOyYi/OWGgxg6ymlwNAAD4OgQ7dOjT46XacrhYAX4W/VvGKLPLAQAAnUCwQ4de2OicjHjhlHglRIaaXA0AAOgMgh3a+fJ0pbYeKZG/n0WLZw83uxwAANBJBDu0s2Kz82rdNycMVHxEX5OrAQAAnUWwQxvHiqu1bm+BJHG1DgAAD0OwQxsvbT4mw5DmJsdodGyY2eUAAIAuINjBJb+yTu9kn5Ek/cs1I0yuBgAAdBXBDi5/2npCTQ5D0xIjlJowwOxyAABAFxHsIEkqr2nUqnNrwv7LNdxbBwCAJyLYQZL0l+0nVdvo0JiB4Zo9KtrscgAAwGUg2EE1Dc1amXVSkvNqncViMbcgAABwWQh20KrPclVR26ShkX21YGyc2eUAAIDLRLDzcY3NLfrT1hOSpHtnD5e/H1frAADwVAQ7H/e/2WdUYK9XTFiwbp00yOxyAADAFSDY+TBHi6EXNx+TJN09M1HBAf4mVwQAAK4Ewc6HbdhXoOMlNbL2CdT3pyWYXQ4AALhCBDsfZRiGlm9yXq37YXqC+gUHmFwRAAC4UgQ7H7XtaIm+PFOpkEA/3Tkj0exyAABANyDY+agV567WfXfKEEWEBplcDQAA6A4EOx+053SFso6VKsDPoh/PGmZ2OQAAoJsQ7HzQX7JOSZJuHB+nQf37mFwNAADoLgQ7H1NW06j/23NWknTH9KHmFgMAALoVwc7HvLkzT43NLRo7KFwT4/ubXQ4AAOhGBDsf4mgx9P996uyGvSNtqCwWlg8DAMCbEOx8yKZDRTpdXqf+fQP1zasGml0OAADoZgQ7H/KX7c6rdbdNjldIIMuHAQDgbQh2PuJESY22HC6WxSLdzvJhAAB4JYKdj2i9t+6aUdEaEtnX5GoAAEBPINj5gLpGh97amSdJuiN9qLnFAACAHkOw8wHv5pyRvb5ZQyL6avaoaLPLAQAAPYRg5+UMw9Br5wZN3J42RH5+THECAIC3Ith5uV2nyrU/367gAD/dNjne7HIAAEAPIth5udardTdfNVD9+waZXA0AAOhJBDsvVlzVoHV78yUxaAK9Z/ny5UpMTFRISIhSU1O1devWi7Z9++23NW/ePEVHRys8PFzp6elav359mzYrV66UxWJp96ivr+/ptwIAHodg58Xe+CxXTQ5DE4f019hBVrPLgQ9YvXq1lixZokceeUTZ2dmaOXOmFixYoNzc3A7bb9myRfPmzdPatWu1a9cuXXvttbrpppuUnZ3dpl14eLjy8/PbPEJCQnrjLQGAR7EYhmGYXQS6X7OjRTP/Z6PyK+v1+4UT9K2Jg80uCT5g2rRpmjRpklasWOHalpycrFtuuUXLli3r1D7GjBmjhQsX6le/+pUk5xW7JUuWqKKi4rLrstvtslqtqqysVHh4+GXvBwDcHVfsvNSHBwqVX1mvyNAgfWNcnNnlwAc0NjZq165dysjIaLM9IyNDWVlZndpHS0uLqqqqFBER0WZ7dXW1EhISNHjwYN14443trugBAJwIdl7qL1nOQRMLp8QrOIB1YdHzSkpK5HA4ZLPZ2my32WwqKCjo1D5+97vfqaamRrfddptrW1JSklauXKn33ntPq1atUkhIiGbMmKEjR45cdD8NDQ2y2+1tHgDgCwLMLgDd70hhlbYfL5WfRfpBGuvCondZLG3nSjQMo922jqxatUqPPvqo3n33XcXExLi2p6WlKS0tzfX9jBkzNGnSJD3//PN67rnnOtzXsmXL9Nhjj13mOwAAz8UVOy/013Prws5NtmlQ/z4mVwNfERUVJX9//3ZX54qKitpdxbvQ6tWrddddd+nNN9/U3LlzL9nWz89PU6ZMueQVu4cffliVlZWuR15eXuffCAB4MIKdl6luaNbbX5yRxBQn6F1BQUFKTU1VZmZmm+2ZmZmaPn36RV+3atUq3XnnnXr99dd1ww03fO3PMQxDOTk5iou7+L2jwcHBCg8Pb/MAAF9AV6yXeeeL06puaNaw6FDNGBFpdjnwMUuXLtWiRYs0efJkpaen6+WXX1Zubq4WL14syXkl7cyZM3rttdckOUPdHXfcoWeffVZpaWmuq319+vSR1eqcouexxx5TWlqaRo4cKbvdrueee045OTl64YUXzHmTAODGCHZe5Px1YRelJXTqviagOy1cuFClpaV6/PHHlZ+fr7Fjx2rt2rVKSHDe65mfn99mTruXXnpJzc3Nuu+++3Tfffe5tv/whz/UypUrJUkVFRW65557VFBQIKvVqokTJ2rLli2aOnVqr743APAEzGPnRXaeLNO3X9yuPoH+2vHIHIWHBJpdEuAWmMcOgK/gHjsv8vddpyVJ3xgXR6gDAMAHEey8RF2jQ+/vca4L+53JrDIBAIAvIth5iQ/25au6oVnxEX00dWjE178AAAB4HYKdl2jthv2nSYPl58egCQAAfBHBzgucLq9V1rFSSc5gBwAAfBPBzgu888UZGYaUPixS8RF9zS4HAACYhGDn4QzD0N+/cHbDfjuVq3UAAPgygp2H+/xkuU6V1io0yF8LxsWaXQ4AADARwc7D/X2Xc3HzG8bHqW8QC4kAAODLCHYerLaxWf84N3fdt1PjTa4GAACYjWDnwdZ9WaCaRocSIvtqytABZpcDAABMRrDzYK1z13170mBZLMxdBwCAryPYeai8slptP14qi0W6ldGwAABABDuPtebcFCczhkdpUP8+JlcDAADcAcHOA7W0GK5gx9x1AACgFcHOA+04Uaa8sjr1Cw7Q9WOYuw4AADgR7DxQ66CJG8fHqU+Qv8nVAAAAd0Gw8zA1Dc1at9c5d913JtMNCwAAvkKw8zBrv8xXbaNDiVGhmjSEuesAAMBXCHYe5q1dXw2aYO46AABwPoKdBzlVWqPPTpQ5566bNMjscgAAgJsh2HmQ/80+K0m6ekSU4qzMXQcAANoi2HkIwzD03u4zkqRbruJqHQAAaI9g5yH259t1rLhGQQF+yhhjM7scAADghgh2HuL/djunOLludIzCQgJNrgYAALgjgp0HMAxD/7fbeX/dN68aaHI1AADAXRHsPMAXuRU6U1Gn0CB/XZcUY3Y5AADATRHsPEDr1bqMMbEKCWQJMQAA0DGCnZtrdrTo/T3O++tumhBncjUAAMCdEezc3I4TZSqpblD/voG6ekS02eUAAAA3RrBzc+/lOLthF4yNU1AAf10AAODiSApurKHZoXV76YYFAACdQ7BzY1sPl8he36yYsGBNS4w0uxwAAODmCHZu7L1zo2FvHD9Q/n4Wk6sBAADujmDnpmobm5W5v1AS3bAAAKBzCHZu6qMDRaprcig+oo+uiu9vdjkAAMADEOzcVGs37E3jB8pioRsWAAB8PYKdG6qsa9LmQ8WSWBsWAAB0HsHODa3fV6BGR4tG2fopKTbc7HIAAICHINi5of87rxsWAACgswh2bqakukFZx0olSTdNINgBAIDOI9i5mXVf5svRYmj8YKuGRoWaXQ4AAPAgBDs3848vzy0hRjcsAADoIoKdGymtbtBnJ8okSfPHxppcDQAA8DQEOzeSub9QLYY0dlC44iP6ml0OAADwMAFmF4CvfLCvQJI0fwxX69C7mpqaVFBQoNraWkVHRysiIsLskgAAl4Erdm7CXt+kT46WSJLmj2VtWPS86upqvfTSS7rmmmtktVo1dOhQpaSkKDo6WgkJCfrxj3+szz//3OwyAQBdQLBzEx8fKFKTw9CImH4aEdPP7HLg5X7/+99r6NCh+uMf/6jrrrtOb7/9tnJycnTo0CFt375d//Vf/6Xm5mbNmzdP8+fP15EjR8wuGQDQCXTFuokP9jq7YRcwaAK9ICsrSxs3btS4ceM6fH7q1Kn653/+Z61YsUKvvvqqNm/erJEjR/ZylQCArrIYhmGYXYSvq2t0aOKvN6i+qUXvP3C1xg6yml0SfEh6errWr1+v8HDvXb7ObrfLarWqsrLSq98nANAV6wY2Hy5SfVOLBg/oozED+aWD3rVjxw7V19e322632/Xv//7vXd7f8uXLlZiYqJCQEKWmpmrr1q0Xbfv2229r3rx5io6OVnh4uCtkXmjNmjVKSUlRcHCwUlJS9M4773S5LgDwBQQ7N3B+N6zFYjG5GviKW2+9VU888YQsFouKioraPV9TU6Onn366S/tcvXq1lixZokceeUTZ2dmaOXOmFixYoNzc3A7bb9myRfPmzdPatWu1a9cuXXvttbrpppuUnZ3tarN9+3YtXLhQixYt0u7du7Vo0SLddttt2rFjR9feMAD4ALpiTdbQ7NDkX3+oqoZmrfmXdKUmMM0EeseDDz6ozz//XFlZWbJYLIqMjNSECRM0YcIEjR8/Xnv27NEbb7yh06dPd3qf06ZN06RJk7RixQrXtuTkZN1yyy1atmxZp/YxZswYLVy4UL/61a8kSQsXLpTdbte6detcbebPn68BAwZo1apVndonXbEAfEWnBk8YhqGqqqqersUnbTlSrEq7XdH9gjTc6i+73W52SfARjz32mCQpKipK69evV0FBgfbs2aM9e/ZozZo1amlp0aOPPtrpz2RjY6N27typn/zkJ21eM3v2bG3ZsqVT+2lpaVFlZaX69Onjav/JJ5/ovvvua7fP5cuXd7q21nb8+wLgycLCwr62Z69TV+xa/7cLAAAAc3Sm16FTwc6TrtjZ7XbFx8crLy/P7btcmh0tuvapTSqvbdKf7pistOGRptThScfMXXDM2svPz1dSUpIyMzM1depU1/bf/va3euONN7Rx48ZLHrO33npLDzzwgFatWqVrr73WtT0yMlIvvviivvOd77i2rV69Wvfff7+Ki4s7rGXZsmV64okn2m33tL8vPmddxzHrOo5Z15l1zDpzxa5TXbEWi8Xj/rLDw8Pdvubtx0pV6QhUxIC+unZ8ggL9zR3L4gnHzN146jHLzc3VkCFDOt3+zJkzGjRo0CXbhISEyN/fX1VVVW2Oid1u18CBA13bOjpmq1ev1gMPPKC33npLN9xwQ5vn4uLiZLfb27ymurpasbGxFz32jz76qB5++OE2NcTHx3vs35en1m0mjlnXccy6zh2PGaNiTbT+3Nqw85Jtpoc6+JYpU6boxz/+sT777LOLtqmsrNQf//hHjR07Vm+//fbX7jMoKEipqanKzMxssz0zM1PTp0+/6OtWrVqlO++8U6+//nq7UCc559m7cJ8bNmy45D6Dg4NdJ1x3PPECQE9h5QmTtLQYrmlO5rPaBHrZzTffrLCwMM2fP1+BgYGaPHmyBg4cqJCQEJWXl2v//v3at2+fJk+erN/+9rdasGBBp/a7dOlSLVq0SJMnT1Z6erpefvll5ebmavHixa429957r2s066pVq3THHXfo2WefVVpamgoKnP8m+vTp47qv96c//almzZqlJ598UjfffLPeffddffjhh9q2bVs3HxUA8HxeF+yCg4P1X//1XwoODja7lEvafbpCBfZ6hQb5a8aIKFNr8ZRj5k48/ZitXLlSeXl5+s1vfiObzaa4uDiVlJSorq5OUVFR+sEPfqDrr79eY8eO7dJ+Fy5cqNLSUj3++OPKz8/X2LFjtXbtWiUkJKihoUETJkzQmTNnXO1feuklNTc367777tN9993n2v7DH/5QK1eulCRNnz5db7zxhn7xi1/ol7/8pYYPH67Vq1dr2rRp3XIs3Jmnf87MwDHrOo5Z17nzMWMeO5MsW3dAL20+rpsmDNTz35todjnwMYmJiVqxYoXmz58vPz8/FRQUKCYmxuyyegzz2AHwFdzYZQLDOK8bdgzdsOh9P/vZz/TNb35T06dPl8Vi0d/+9jd9/vnnqqurM7s0AMAVINiZ4GBBlU6V1io4wE/XjI42uxz4oPvuu0/Z2dm68cYbZRiGXnjhBaWnpys8PFzJycn67ne/qyeeeKLNag8AAPdHV6wJfp95WM9+dETzUmz64x2TzS4HPm7EiBH69NNPFRoaqj179ignJ8f12Lt3r8fMYXkpdMUC8BVeN3jCE9ANC3dy9OhR19fTpk1rMyiB//cBgGfxiK7Y5cuXKzExUSEhIUpNTdXWrVsv2vbtt9/WvHnzFB0drfDwcKWnp2v9+vVt2qxcuVIWi6Xdo76+vqffio4XV+tQYZUC/Cyam2zrsZ/TlWO2adOmDo/HwYMH27Rbs2aNUlJSFBwcrJSUFL3zzjs9Vr8ZunLM7rzzzg6P2ZgxY1xtzPycdZeLzXC+ZcsW3XTTTRo4cKAsFov+93//92v3tXnzZqWmpiokJETDhg3Tiy++2K6NN3/GunrM3P1c1hu6esw4l3X9mPnKuexSli1bpilTpigsLEwxMTG65ZZbdOjQoa99nbue09w+2K1evVpLlizRI488ouzsbM2cOVMLFixQbm5uh+23bNmiefPmae3atdq1a5euvfZa3XTTTcrOzm7TLjw8XPn5+W0eISEhPf5+MvcXSpLSh0fK2jewR35GV49Zq0OHDrU5HiNHjnQ9t337di1cuFCLFi3S7t27tWjRIt12223asWNHj7yH3tbVY/bss8+2OVZ5eXmKiIhos+yVZN7nrKfV1NRowoQJ+sMf/tCp9idOnNA3vvENzZw5U9nZ2frP//xP/eQnP9GaNWtcbbz9M9bVY+bu57Le0NVj1sqXz2VdPWa+fi6TnAHtvvvu06effqrMzEw1NzcrIyNDNTU1F32NW5/TDDc3depUY/HixW22JSUlGQ899FCn95GSkmI89thjru///Oc/G1artbtK7JLvrMgyEn7+vvGXrBM99jO6esw2btxoSDLKy8svus/bbrvNmD9/fptt119/vfHd7373iut1B1f6OXvnnXcMi8VinDx50rXNzM9Zb5JkvPPOO5ds8x//8R9GUlJSm2333nuvkZaW5vq+Jz9jlZWVhiSjsrLyivfVHTpzzDriTuey3taZY8a5rK3L+Zz58rmsVVFRkSHJ2Lx580XbmH1OuxS3vmLX2NioXbt2KSMjo832jIwMZWVldWofLS0tqqqqUkRERJvt1dXVSkhI0ODBg3XjjTe2+19wTyivadTOU2WSpOuSembOsCs5ZhMnTlRcXJzmzJmjjRs3tnlu+/bt7fZ5/fXXd/rvwZ11x+fslVde0dy5c5WQkNBmuxmfM3d0sc/Pzp071dTUdMk23vAZ6w7udC5zd756LusOnMucyylKavdv7XzufE5z62BXUlIih8Mhm63tvWg2m8219NDX+d3vfqeamhrddtttrm1JSUlauXKl3nvvPa1atUohISGaMWOGjhw50q31X2jT4SK1GFJSbJgGD+jbIz/jco5ZXFycXn75Za1Zs0Zvv/22Ro8erTlz5mjLli2uNgUFBVf09+DOrvRzlp+fr3Xr1unuu+9us92sz5k7utjnp7m5WSUlJZds4w2fse7gTucyd+Xr57IrxbnMOWBs6dKluvrqqy+58o47n9M8YlTshTdwG4Zx0Zu6z7dq1So9+uijevfdd9vMqp+Wlqa0tDTX9zNmzNCkSZP0/PPP67nnnuu+wi/w4YEiSdKc5J6f4b8rx2z06NEaPXq06/v09HTl5eXpqaee0qxZsy5rn57oct/fypUr1b9/f91yyy1ttpv1OXNXHR3fC7d7+2fscrnbucxdcS67MpzLpPvvv1979uzp1FrU7npOc+srdlFRUfL392+XbouKitql4AutXr1ad911l958803NnTv3km39/Pw0ZcqUHv3fR2Nzi7YcKpYkzenB0bBXcszOl5aW1uZ4xMbGXvE+3dWVHDPDMPTqq69q0aJFCgoKumTb3vicuauLfX4CAgIUGRl5yTbe8Bm7Eu52LvM0vnQuuxKcy6QHHnhA7733njZu3KjBgwdfsq07n9PcOtgFBQUpNTVVmZmZbbZnZmZq+vTpF33dqlWrdOedd+r111/XDTfc8LU/xzAM5eTkKC4u7oprvpjPT5apqqFZUf2CdNXg/j32cy73mF0oOzu7zfFIT09vt88NGzZ0aZ/u6kqO2ebNm3X06FHdddddX/tzeuNz5q4u9vmZPHmyAgMDL9nGGz5jl8sdz2WexpfOZVfCl89lhmHo/vvv19tvv62PP/5YiYmJX/satz6n9ejQjG7wxhtvGIGBgcYrr7xi7N+/31iyZIkRGhrqGrHz0EMPGYsWLXK1f/31142AgADjhRdeMPLz812PiooKV5tHH33U+OCDD4xjx44Z2dnZxo9+9CMjICDA2LFjR4+9j0ff22sk/Px942dv5vTYz2jV1WP2+9//3njnnXeMw4cPG3v37jUeeughQ5KxZs0aV5tPPvnE8Pf3N5544gnjwIEDxhNPPGEEBAQYn376aY+/n97Q1WPW6vbbbzemTZvW4T7N+Jz1lqqqKiM7O9vIzs42JBlPP/20kZ2dbZw6dcowjPbH6/jx40bfvn2NBx980Ni/f7/xyiuvGIGBgcbf//53V5ue/Iy5w6jYrh4zdz2X9aauHjPOZV0/Zq189VxmGIbxL//yL4bVajU2bdrU5t9abW2tq427ndMuxe2DnWEYxgsvvGAkJCQYQUFBxqRJk9oMQf7hD39ozJ492/X97NmzDUntHj/84Q9dbZYsWWIMGTLECAoKMqKjo42MjAwjKyurx+pvaWkxZj75sZHw8/eNdV/m99jPOV9XjtmTTz5pDB8+3AgJCTEGDBhgXH311cY//vGPdvt86623jNGjRxuBgYFGUlJSm5OlN+jKMTMMw6ioqDD69OljvPzyyx3ur7c/Z72pdVqJi/076+h4bdq0yZg4caIRFBRkDB061FixYkW7/fbUZ8wdgl1Xj5k7nst6W1ePGeeyy/u36cvnMsMwOjxekow///nPrjbudk67FNaK7QVHi6o09+ktCvL3U/av5ik02CPGrABeg7ViAfgKt77Hzlu0joZNGx5JqAMAAD2GYNcLPjrgXEZsbi9McwIAAHwXwa6Hldc0atepckk9t9oEAACARLDrcRsP9fxqEwAAABLBrsd9dO7+urk9OCkxAACARLDrUY3NLdp8uHW1CbphAQBAzyLY9aDPT5apuqFZUf2CNaEHV5sAAACQCHY96sNzo2GvS4qWnx8LTAMAgJ5FsOshhmG47q+7Lon76wAz/fznPze7BADoFQS7HnK0qFq5ZbUK8vfTzJFRZpcD+LQvvvjC7BIAoFcQ7HpI62oT6aw2AZimqalJQUFB+uyzzyRJVqtV06ZNM7kqAOg5BLsewmoTgPn8/f21bds21/eHDx/W+vXrTawIAHoWwa4HlNU06ovcc6tNMH8dYBo/Pz+dPXtWAwYMkCTZbDb179/f3KIAoAcR7HrAxoPO1SaS48I1qH8fs8sBfFp2drbGjRtndhkA0CsIdj3g44Otq03QDQuYLScnR2PHjjW7DADoFQS7bnb+ahPXJRHsALN9+eWXBDsAPoNg180+O8FqE4A7aWlp0d69eyVJlZWVJlcDAD2LYNfNWG0CcC+/+c1v9Pbbb0uSnnzySZOrAYCeZTEMwzC7CG9hGIZm/Xaj8srq9NKiVF0/JtbskgBIstvtslqtqqysVHh4uNnlAECP4YpdNzpWXK28sjoF+fvp6hGsNgEAAHoXwa4bbTrkHDQxbVgEq00AAIBeR7DrRq2jYWePija5EgAA4IsIdt2ktrFZO46XSZKuGc00JwAAoPcR7LrJ9mOlanS0aFD/PhoeHWp2OQAAwAcR7LpJazfsNaOjZbEwzQkAAOh9BLtuYBiGa+AE3bAAAMAsBLtucKKkRrlltQr0tyh9eKTZ5QAAAB9FsOsGrVfrpgyNUD+mOQEAACYh2HWD8++vAwAAMAvB7grVNzn06fFSSdxfBwAAzEWwu0Lbj5eqoblFcdYQjYzpZ3Y5AADAhxHsrtDmQ0xzAgAA3APB7gp9tYwY3bAAAMBcBLsrcKq0RidKahTgZ9GMEUxzAgAAzEWwuwKt05ykJgxQWEigydUAAABfR7C7ApsOFUliNCwAAHAPBLvLVN/k0HbXNCfMXwe0Wr58uRITExUSEqLU1FRt3br1om3z8/P1/e9/X6NHj5afn5+WLFnSrs3KlStlsVjaPerr63vwXQCAZyLYXabPTpSpvqlFtvBgJcWGmV0O4BZWr16tJUuW6JFHHlF2drZmzpypBQsWKDc3t8P2DQ0Nio6O1iOPPKIJEyZcdL/h4eHKz89v8wgJCemptwEAHotgd5la76+bPYppToBWTz/9tO666y7dfffdSk5O1jPPPKP4+HitWLGiw/ZDhw7Vs88+qzvuuENWq/Wi+7VYLIqNjW3zAAC0R7C7TJsOc38dcL7Gxkbt2rVLGRkZbbZnZGQoKyvrivZdXV2thIQEDR48WDfeeKOys7Mv2b6hoUF2u73NAwB8AcHuMuSV1ep4cY38/SyaMSLK7HIAt1BSUiKHwyGbzdZmu81mU0FBwWXvNykpSStXrtR7772nVatWKSQkRDNmzNCRI0cu+pply5bJarW6HvHx8Zf98wHAkxDsLsOmc5MSTxrSX9Y+THMCnO/CWxMMw7ii2xXS0tJ0++23a8KECZo5c6befPNNjRo1Ss8///xFX/Pwww+rsrLS9cjLy7vsnw8AniTA7AI80WamOQHaiYqKkr+/f7urc0VFRe2u4l0JPz8/TZky5ZJX7IKDgxUcHNxtPxMAPAVX7LqoodmhrGPOaU5mj2KaE6BVUFCQUlNTlZmZ2WZ7Zmampk+f3m0/xzAM5eTkKC4urtv2CQDegit2XbTzZLlqGx2KDgvWmIHhZpcDuJWlS5dq0aJFmjx5stLT0/Xyyy8rNzdXixcvluTsIj1z5oxee+0112tycnIkOQdIFBcXKycnR0FBQUpJSZEkPfbYY0pLS9PIkSNlt9v13HPPKScnRy+88EKvvz8AcHcEuy5qXW1i1kimOQEutHDhQpWWlurxxx9Xfn6+xo4dq7Vr1yohIUGSc0LiC+e0mzhxouvrXbt26fXXX1dCQoJOnjwpSaqoqNA999yjgoICWa1WTZw4UVu2bNHUqVN77X0BgKewGIZhmF2EJ5n39GYdKarW89+bqJsmDDS7HACdYLfbZbVaVVlZqfBwrrQD8F7cY9cFZyvqdKSoWn4WaeZIpjkBAADuhWDXBVuPOKc5mRDfX/37BplcDQAAQFsEuy7YcrhEkvP+OgAAAHdDsOskR4uhbUfPBbtRdMMCAAD3Q7DrpC/PVKqyrklhIQGaMLi/2eUAAAC0Q7DrpC3nlhGbMTxKAf4cNgAA4H5IKJ3UOnBiJt2wAADATRHsOsFe36QvciskMXACAAC4L4JdJ2w/VipHi6HEqFDFR/Q1uxwAAIAOEew6obUbdhaTEgMAADdGsOuE1vnrZtINCwAA3BjB7mucKq1RblmtAv0tSh8eaXY5AAAAF0Ww+xqt05xMGjJAocEBJlcDAABwcQS7r7HlSOtqE3TDAgAA90awu4QmR4u2HyuVxDQnAADA/RHsLiE7t0LVDc2KCA3SmIHhZpcDAABwSQS7S2id5uTqEVHy87OYXA0AAMClEewuoXXgxEzmrwMAAB6AYHcR5TWN2nOmUhIDJwAAgGcg2F3EJ8dKZBjSaFuYbOEhZpcDAADwtQh2F9HaDTtrFN2wAADAMxDsOmAYhrYeYRkxAADgWQh2HThaVK38ynoFB/hpamKE2eUAAAB0CsGuA62rTUxNjFBIoL/J1QAAAHQOwa4DrfPXsdoEAADwJAS7CzQ0O/Tp8XPLiDHNCQAA8CAEuwvsPFmu+qYWxYQFa5Stn9nlAAAAdBrB7gLnj4a1WFhGDAAAeA6C3QVc99cxfx0AAPAwBLvzlFQ3aN9ZuyRpxgiCHQAA8CwEu/N8ctTZDZsSF66ofsEmVwMAANA1BLvzuO6voxsWAAB4IILdOc5lxJz3180cwTQnAADA8xDszjlaVK1Ce4OCA/w0eegAs8sBAADoMoLdOSwjBgAAPB3B7hyWEQMAAJ6OYCfnMmI7jpdJYuAEAADwXAQ7SbtOlauuyaHosGCNtoWZXQ4AAMBlIdjpvGlORkSxjBgAAPBYBDtJ25i/DgAAeAGfD3al1Q3ae7ZSEsuIAQAAz+bzwe6TY6UyDCkpNkwxYSFmlwMAAHDZfD7YbWud5mQU05wAAADP5tPBzrmMmPP+uqvphgUAAB7Op4PdseJq5VfWKyjAT1MTI8wuBwAA4Ir4dLBrvVo3jWXEAACAFyDYiW5YAADgHXw22DU2t+jT46WSpJmsDwsAALyAzwa7L3LLVdvoUFS/YCXFsowYAADwfD4b7Laem+bk6hGR8vNjGTEAAOD5fDbYuZYRoxsW6FbLly9XYmKiQkJClJqaqq1bt160bX5+vr7//e9r9OjR8vPz05IlSzpst2bNGqWkpCg4OFgpKSl65513eqh6APBsPhnsymsateeMcxmxq0cycALoLqtXr9aSJUv0yCOPKDs7WzNnztSCBQuUm5vbYfuGhgZFR0frkUce0YQJEzpss337di1cuFCLFi3S7t27tWjRIt12223asWNHT74VAPBIFsMwDLOL6G3v7zmr+1/P1mhbmNY/OMvscgCvMW3aNE2aNEkrVqxwbUtOTtYtt9yiZcuWXfK111xzja666io988wzbbYvXLhQdrtd69atc22bP3++BgwYoFWrVnWqLrvdLqvVqsrKSoWHh3f+DQGAh/HJK3ZbD5+b5oSrdUC3aWxs1K5du5SRkdFme0ZGhrKysi57v9u3b2+3z+uvv/6S+2xoaJDdbm/zAABf4HPBzjAMbWF9WKDblZSUyOFwyGaztdlus9lUUFBw2fstKCjo8j6XLVsmq9XqesTHx1/2zwcAT+Jzwe5okXMZseAAP01jGTGg21ksbUeZG4bRbltP7/Phhx9WZWWl65GXl3dFPx8APEWA2QX0ts2HnVfrprKMGNCtoqKi5O/v3+5KWlFRUbsrbl0RGxvb5X0GBwcrODj4sn8mAHgqn7ti17qM2CymOQG6VVBQkFJTU5WZmdlme2ZmpqZPn37Z+01PT2+3zw0bNlzRPgHAW/nUFbv6Jod2nHAuI8b9dUD3W7p0qRYtWqTJkycrPT1dL7/8snJzc7V48WJJzi7SM2fO6LXXXnO9JicnR5JUXV2t4uJi5eTkKCgoSCkpKZKkn/70p5o1a5aefPJJ3XzzzXr33Xf14Ycfatu2bb3+/gDA3flUsPv8ZJnqm1oUGx6iUbZ+ZpcDeJ2FCxeqtLRUjz/+uPLz8zV27FitXbtWCQkJkpwTEl84p93EiRNdX+/atUuvv/66EhISdPLkSUnS9OnT9cYbb+gXv/iFfvnLX2r48OFavXq1pk2b1mvvCwA8hU/NY/ff/9ivP249oe+kDtZvv9PxZKgAvA/z2AHwFT51j92Wc/PX0Q0LAAC8kc8Eu4LKeh0qrJLFIl09gomJAQCA9/GZYLf13KTE4wdZNSA0yORqAAAAup/PBLstR+iGBQAA3s0ngp2jxdA2lhEDAABezieC3d4zlSqvbVJYcICuiu9vdjkAAAA9wieC3ZZzy4hNHxGpQH+feMsAAMAH+UTK2XKuG3Ymy4gBAAAv5vXBzl7fpC9yKyRJs7m/DgAAeDGvD3bbj5XK0WIoMSpU8RF9zS4HAACgx3h9sGu9v27WSCYlBgAA3s2rg51hGK7765jmBAAAeDuvDnYnS2uVV1anQH+L0oZFml0OAABAj/LqYNfaDZuaMEChwQEmVwMAANCzfCLY0Q0LAAB8gdcGu8bmFm0/XipJmsX8dQAAwAd4bbDbdapctY0ORfULUkpcuNnlAAAA9DivDXbnrzbh52cxuRoAAICe573BznV/HfPXAQAA3+CVwa6kukH7ztolSVeP4P46AADgG7wy2G0+5LxalxIXruiwYJOrAQAA6B1eGew+PlgkSZqTHGNyJQAAAL3H64Jdk6PFdX/ddUkEOwAA4Du8Lth9frJMVQ3NigwN0oTB/c0uBwAAoNd4XbD7+ICzG/aa0TFMcwIAAHyK9wW7Q9xfBwAAfJNXBbsTJTU6XlyjAD+Lrh7J/HUAAMC3eFWwax0NOzUxQuEhgSZXAwAA0Lu8KthtPBfsGA0LAAB8kdcEu+qGZu04USqJYAcAAHyT1wS7bUeK1eQwlBgVqmHR/cwuBwAAoNd5TbD76ADdsAAAwLd5RbBraTG08RDBDgAA+DavCHZfnqlUSXWj+gUHaMrQCLPLAQAAMIVXBLuPzo2GnTUqSkEBXvGWAAAAuswrUtDHBwslSdeOphsWAAD4Lo8PdoX2eu09Y5fF4lwfFgAAwFd5fLBrnZR4wuD+ig4LNrkaAAAA83h8sPuI1SYAAAAkeXiwq29y6JOjJZIIdgAAAB4d7HacKFNto0O28GCNGRhudjkAAACm8uhgt/G8bliLxWJyNQAAAOby2GBnGIY+OjfNyXVJNpOrAQAAMJ/HBrujRdXKK6tTUICfZoyINLscAAAA03lssPv4XDds+rBI9Q0KMLkaAAAA83lssGud5mROMqNhAQAAJA8NdpW1Tdp1qlwSy4gBAAC08shgt/lIsRwthkbZ+ik+oq/Z5QAAALgFjwx2Hx9gNCwAAMCFPC7YOVoMbTpcLIn76wAAAM7nccHui9xyVdQ2ydonUBPj+5tdDoALLF++XImJiQoJCVFqaqq2bt16yfabN29WamqqQkJCNGzYML344ottnl+5cqUsFku7R319fU++DQDwSB4X7NZ+mS/JudpEgL/HlQ94tdWrV2vJkiV65JFHlJ2drZkzZ2rBggXKzc3tsP2JEyf0jW98QzNnzlR2drb+8z//Uz/5yU+0Zs2aNu3Cw8OVn5/f5hESEtIbbwkAPIpHTQDX0mK4gt0N4+JMrgbAhZ5++mnddddduvvuuyVJzzzzjNavX68VK1Zo2bJl7dq/+OKLGjJkiJ555hlJUnJysnbu3KmnnnpK//RP/+RqZ7FYFBsb2yvvAQA8mUdd8vr8ZJkK7Q0KCwnQzFFRZpcD4DyNjY3atWuXMjIy2mzPyMhQVlZWh6/Zvn17u/bXX3+9du7cqaamJte26upqJSQkaPDgwbrxxhuVnZ3d/W8AALyARwW7f5y7Wnf9mFgFB/ibXA2A85WUlMjhcMhmazta3WazqaCgoMPXFBQUdNi+ublZJSUlkqSkpCStXLlS7733nlatWqWQkBDNmDFDR44cuWgtDQ0NstvtbR4A4As8Jtg5Wgyt/dL5y+HG8XTDAu7KYrG0+d4wjHbbvq79+dvT0tJ0++23a8KECZo5c6befPNNjRo1Ss8///xF97ls2TJZrVbXIz4+/nLfDgB4FI8JdjuOl6qkukH9+wZqxgi6YQF3ExUVJX9//3ZX54qKitpdlWsVGxvbYfuAgABFRkZ2+Bo/Pz9NmTLlklfsHn74YVVWVroeeXl5XXw3AOCZPCbY/d8eZzfs/DGxCmQ0LOB2goKClJqaqszMzDbbMzMzNX369A5fk56e3q79hg0bNHnyZAUGBnb4GsMwlJOTo7i4i1+5Dw4OVnh4eJsHAPgCj0hITY4WfbDXGexuHD/Q5GoAXMzSpUv1pz/9Sa+++qoOHDigBx98ULm5uVq8eLEk55W0O+64w9V+8eLFOnXqlJYuXaoDBw7o1Vdf1SuvvKKf/exnrjaPPfaY1q9fr+PHjysnJ0d33XWXcnJyXPsEAHzFI6Y72X6sVOW1TYoMDVLasAizywFwEQsXLlRpaakef/xx5efna+zYsVq7dq0SEhIkSfn5+W3mtEtMTNTatWv14IMP6oUXXtDAgQP13HPPtZnqpKKiQvfcc48KCgpktVo1ceJEbdmyRVOnTu319wcA7s5itN6p7Mb+4++79ebO07o9bYh+c8s4s8sB4GHsdrusVqsqKyvplgXg1dy+K7axuUUf7HXeXH3DOLphAQAALsbtg922o8Wy1zcrOixYUxPphgUAALgYtw927+/+agkxf7+Lz4UFAADg69w62NU3OZS5v1ASkxIDAAB8HbcOdlsOF6uqoVlx1hBNGjLA7HIAAADcmlsHu/fPTUr8jXFx8qMbFgAA4JLcNtjVNTr04QG6YQEAADrLbYPdpkNFqm10aPCAProqvr/Z5QAAALg9tw12rd2wN4yPk8VCNywAAMDXcctgV9PQrI8OnuuGZVJiAACATnHLYPfRwSLVN7UoIbKvxg5i+R8AAIDOcMtg9/7us5KcgybohgUAAOgctwt2VfVN2nS4WJJ043i6YQEAADrL7YLdhwcK1djcomHRoUqKDTO7HAAAAI8RYHYBF0qJs+rO6UM1JKIv3bAAAABdYDEMwzC7CADoSXa7XVarVZWVlQoPZ0AWAO/ldl2xAAAAuDwEOwAAAC9BsAMAAPASBDsAAAAvQbADAADwEgQ7AAAAL0GwAwAA8BIEOwAAAC9BsAMAAPASBDsAAAAvQbADAADwEgQ7AAAAL0GwAwAA8BIEOwAAAC9BsAMAAPASBDsAAAAvQbADAADwEgQ7AAAAL0GwAwAA8BIWwzAMs4sAgJ5kGIaqqqoUFhYmi8VidjkA0GMIdgAAAF6CrlgAAAAvQbADAADwEgQ7AAAAL0GwAwAA8BIEOwAAAC9BsAMAAPASBDsAAAAv8f8Ddz4UZzdaFREAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2be5f17ec10>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr2,(t,0.2,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\left(t e^{\\frac{1}{t}} + t e^{\\frac{1}{2 - t}} - 2 e^{\\frac{1}{2 - t}}\\right) e^{- \\frac{1}{t}} e^{- \\frac{1}{2 - t}}}{t \\left(t - 2\\right)}$"
      ],
      "text/plain": [
       "-(t*exp(1/t) + t*exp(1/(2 - t)) - 2*exp(1/(2 - t)))*exp(-1/t)*exp(-1/(2 - t))/(t*(t - 2))"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(expr2.subs(t,2-t)-expr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2be5e68f390>"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr1,(x,-2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.19166666666666668"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "23/120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.core.random import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.core.random import _randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=3000\n",
    "a=1\n",
    "b=5\n",
    "count=0\n",
    "count_list=[]\n",
    "frequent_list=[]\n",
    "for i in range(1,n+1):\n",
    "    rand=randint(a,b)\n",
    "    if(rand<3):\n",
    "        count+=1\n",
    "    count_list.append(count)\n",
    "    frequent_list.append(count/i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2be5e6c3050>,\n",
       " <matplotlib.lines.Line2D at 0x2be5f6489d0>]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGdCAYAAADAAnMpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA320lEQVR4nO3deXxU1f3/8fdkshKSYQkJBEIIyB5ACQoBERUbwa24tNQFaJVWWrVStP2J9KtIF/i2SrH9GhDrUqwLtai1FZdYEaJBUQzKDsqSAAkhAZJAIJPM3N8fSYZM1pkw4Sbc1/PxmEeTO+feOXM6Mu+c+7nn2gzDMAQAAGCSILM7AAAArI0wAgAATEUYAQAApiKMAAAAUxFGAACAqQgjAADAVIQRAABgKsIIAAAwVbDZHfCF2+3WoUOHFBUVJZvNZnZ3AACADwzDUGlpqeLj4xUU1Pj8R7sII4cOHVJCQoLZ3QAAAC2Qm5urXr16Nfp8uwgjUVFRkqreTHR0tMm9AQAAvigpKVFCQoLne7wx7SKM1JyaiY6OJowAANDONFdiQQErAAAwFWEEAACYijACAABMRRgBAACmIowAAABTEUYAAICpCCMAAMBUhBEAAGAqwggAADBVi8JIenq6kpKSFB4erpSUFGVmZjba9qOPPpLNZqv32LFjR4s7DQAAzh9+h5GVK1dq9uzZmjdvnrKzszV+/HhNnjxZOTk5Te63c+dO5eXleR79+/dvcacBAMD5w+8wsnjxYt11112aOXOmBg8erCVLlighIUFLly5tcr/Y2Fh1797d87Db7S3uNAAAOH/4FUacTqc2btyotLQ0r+1paWnKyspqct+LLrpIPXr00MSJE7VmzZom25aXl6ukpMTr0Vr+/N/d+v6y9XJWulvtNQAAQOP8CiOFhYVyuVyKi4vz2h4XF6f8/PwG9+nRo4eWL1+uVatW6fXXX9fAgQM1ceJErVu3rtHXWbhwoRwOh+eRkJDgTzd9Vnq6QoszdmnDvqN6as03rfIaAACgacEt2anurYANw2j09sADBw7UwIEDPb+npqYqNzdXjz/+uC677LIG95k7d67mzJnj+b2kpKRVAskpp8vz8+f7jgb8+AAAoHl+zYzExMTIbrfXmwUpKCioN1vSlDFjxmj37t2NPh8WFqbo6GivR2szjFZ/CQAA0AC/wkhoaKhSUlKUkZHhtT0jI0Njx471+TjZ2dnq0aOHPy/dOmpN5hgijQAAYAa/T9PMmTNH06ZN06hRo5Samqrly5crJydHs2bNklR1iuXgwYNasWKFJGnJkiXq06ePhg4dKqfTqb///e9atWqVVq1aFdh3cpaYGQEAwBx+h5GpU6eqqKhICxYsUF5enpKTk7V69WolJiZKkvLy8rzWHHE6nXrwwQd18OBBRUREaOjQoXr77bd1zTXXBO5dAACAdstmGG1/TqCkpEQOh0PFxcUBrR85Ulqui3/3gSTpkqQu+sfdqQE7NgAAVufr9zf3pqnR5iMZAADnJ0uHERsFrAAAmM7SYQQAAJiPMFKt7VfOAABwfiKMVCOLAABgDkuHkdoL2LeDi4oAADgvWTqMAAAA8xFGqjEvAgCAOSwdRmrfaZizNAAAmMPSYaQ2sggAAOYgjNRgagQAAFMQRqoRRQAAMIelw4j3pb2mdQMAAEuzdhjh3jQAAJjO0mGkNmZGAAAwB2GkGmEEAABzEEYAAICpCCPVmBgBAMAchJFq3CgPAABzWDqMkD8AADCfpcMIAAAwH2GkGrMkAACYgzBSjUXPAAAwB2GkGjMjAACYw9JhxGjkZwAAcO5YOowAAADzEUaqsc4IAADmIIxUI4sAAGAOS4cRZkMAADCfpcMIAAAwH2GkGnMkAACYgzBSjVM2AACYw9JhhHVGAAAwn6XDSG1MjAAAYA7CSDU3aQQAAFMQRgAAgKkII9WYGAEAwByWDiMEEAAAzGfpMFIbl/YCAGAOwkg1N1kEAABTEEaqGaw0AgCAKSwdRmoHEM7SAABgDkuHEQAAYD7CSDUmRgAAMAdhpBqnaQAAMIe1w4jR6C8AAOAcsXYYqYVLewEAMAdhpBqLngEAYA7CSDWiCAAA5iCMVHNzngYAAFNYOowYjfwMAADOHUuHEQAAYD7CSA2mRgAAMAVhpJqbq2kAADCFpcNI7fxBFAEAwByWDiO1tWRixDAMHS9zBr4zAABYSLDZHWgrjBbMjTz8xha9siFHK38yRqP7dm2FXgGAfwzDkM1ma7ZdeaVLT36wW1sPleiOMYn6YNthBQXZdPvo3hrSI1pBQTY9teYbvfp5jm68qJcuiO2og8dO6dDxU0roEqFpY/ooLLjq79mgoOZfD2hKi8JIenq6/vjHPyovL09Dhw7VkiVLNH78+Gb3++STTzRhwgQlJydr06ZNLXnpVtOSmZFXNuRIkv70wS69+pPUAPfIPJm7j+jJD3brmemj1Dky1OzuAGjGlznHtPSjb5Wx7bBn2/dSeinr2yKdqnCpzFmpX187RHeMSdR7W/O1Pa9ESz7Y7Wm7dtcRz881/67V9uf/7q637ferd3j9PiM1UQ9fO1hhwfZAvCVYjN9hZOXKlZo9e7bS09M1btw4Pf3005o8ebK2bdum3r17N7pfcXGxpk+frokTJ+rw4cONtjuXas+G+JtFFr+/0/Pzp3uO6uPdhbq0f0yAemaeohPlmvbsBknS5Ccz9enDE03uEdA+fFNQqpl/+0KHik/rR2P7aE7agIB+MecXn9bijJ3KLynXulrhoTGvbTzg9fuv39yiX7+5JWD9qetv6/dr04FiLbtjpHo4IlrtdXB+shl+3pRl9OjRGjlypJYuXerZNnjwYE2ZMkULFy5sdL8f/OAH6t+/v+x2u958802/ZkZKSkrkcDhUXFys6Ohof7rbpMKta/S7l96TJAUH2fTH743wab/iUxWa/9bWetv/eMtwBdvbZxnOyfJKHTlRrne35mtnXqln+6PXD9WxMqeSYiJN7B3ORpnTpQ+2H9bovl0UFxVuSh9yjpbp5c9ydLjktCSpQ6hd91/VX7E+9Gd/UZk+/uaIrh8er+iIEJ9fs8zpUkHpaR0uOa2T5ZUa2tOhuKhwHSo+pfAQu7p0CMysn9swtOidHTpSWl7vuSsHxera4T0U5MNpk4YUnijX5gPH9dZXeWfbzQbNmtBXA7tHK+domU45XerdtYOKTpRrU+5xbc8r0XUj4jW4e7Qq3W4dPelUdHiIQoODdLK8Uuu/LdLOw6UKsQdpZ/6ZfzOiwoM1LbWP+nWLbPH7hkn6p0kdugT0kL5+f/sVRpxOpzp06KDXXntNN954o2f7/fffr02bNmnt2rUN7vf8888rPT1d69ev129/+9tmw0h5ebnKy8/8h11SUqKEhISAh5FTr/xQETvfCNjxAABot+5eJ/Xw7Y9yX/kaRvw6TVNYWCiXy6W4uDiv7XFxccrPz29wn927d+uhhx5SZmamgoN9e7mFCxfqscce86drLVIRM0Qbtn0rSeruCNfAuCif9iurcOnzvUcbfG7CgG4B69+5Uu5y69Nvi3xuf3FSF+UXn5YhqW9MpPjbxxx5xae1r+ikBvWIUueIqr/yT1W4tKGRz2aNwT2iFRsV1ujzx8qc+vpAcZPH6BMTqcQuHby2GZL2FJ7UgaNlvr2BsxAaHKQQe9Vf6OeSo0OIissqGnwuPMSuUX06y26z6aSzUhv3H6tXixYbFaaCWjMow3s55HQZ6hoZqoLS0yosdepYE1fopSR2VkSoXfY2OuPgMgztOlyqgpL6s0R1hYfY1S0qTKWnK9Srcwd1iQzVqQqXbJJC7EEyJIXUKYx1utw6cbpSHcODdaK8UsfLKtSzU4TCgoNUWl6pvYUndbzMqYgQuwbERSkqIsTrklG3vC8hrXC5lZ17XJJ0yulSz84RSuwaqcLScu2qnvUZ3CNKUeEhchuGQuxBcla6tSn3uE5XuLz6FhkWrP5xHRUVHiKb1OC/i27DkNNlKDy4jc6gh3Y07aVbVMBat1K7septl8ul2267TY899pgGDBjg8/Hnzp2rOXPmeH6vmRkJtJOX3KcZ/x0qSfp+n176wy2+JcJ9h0o048+ZDT63945rfKpkbyuKyyr04qf79PiOXV7bV/10rG5emtXwTrWaTktK1ILvDm1X7/lsLM7YpT//d7fCgoP0/i8uU2LX+qevvik4oe6OcLnchiJD7c2euisoOa07nv1Muw6fkCT97c5LdOkFMbI3cYXCqo0H9MBrX1X9skf64dg+eiFrX6Ptvb4Eq+sTUxI7q3eXDnoj+6AkKcgmLZ82SjNXfNFkfyVJedWPahf17qQrBsZq8dZdDTbv1TlC/3vzcI27oKqu6niZUxcuyGj+daq98KOL9at/fn3mPTScB+r5v9su0oC4KHWJDNWHOwr04fYCTR7WXf/ceECZuwt9fn2PRjLaVYNj9cz0UZ7/DiIlXSZpzY4C/eiFz880rJsT9zb+Uh3DgjX3mkGaOChO3R3mnF7zl13SIMPQif3H9OL6/frP14fU6D1IKyTV5Nams696dopQpdutww2FnIZKEJ2S9lT9ODm5uy6I7ai/fPhN82+goPpRu49N/H/kpULSiTO/DoyL0s7DVaevenaK0MHjp7yaX3pBjH5/4zD17loV6p2VboUGIKQcL3Nq7a4jGndBjDqGBSs8xK4Ne4/ql//8SqH2IOUXn1Z0RIjKnJVK7unQLSm91KlDqEYndVF4iHnFx616mub48ePq3Lmz7PYzb9DtdsswDNntdr3//vu68sorm33d1qoZOXT8lMYu+lBSVeW5rzUjX+Yc003pDX9Rb1twtTqEto8rpo+Uluvi331Qb/uvrx2smeP7ylnpltPlVvKj7zV7rLd/fqmGxjtao5vnTPGpCn2Ve1zj+8d4vlR2HS7V3Nc36y+3XqQyp0tXLW74VOS1w3ro9zcO0wtZ+/SnDxr+Qu7UIURZD12pEHuQXG5D4SF2udyG+j28usH2aUPitOyOFNlsVVd71Vw+eeBYmS793zXNvp8ukaE6erLqr+xP505U1reFmvOPr5rdr0bfmEjtKTwpSYrpGKrCE76vqTM9NVHDejp04NgpTRwcq+G9OtVrYxiGPtt7VBcmdFJ4iF3b80qUnXNc//giV5uq/1p99Poh+tG4JM8+Kz/P0f9btbnesV740cX67/YCTRjQTdERIeof21EdwuxNFpAWnijXO5vzdP2IeHWqrh+pdLk1e+Um/efrqqR19dA4vbe14YL7h68ZpE/3HFX67SOb/Ud826ESXdPIHzB1DekRrX/fd2mTYbS9KC6rkNPl1jcFJ3S8zKmXPsvRFYNitb/opFas32929wIiMtSuk05X8w19YA+yKTo8WMcamX2bMKCbfjslWQnVs5I78kt06PgpVbgMzXtjs1//jTbkie+N0M0pvc7qGHW1Ss2IVFXAmpKSovT0dM+2IUOG6Lvf/W69Ala3261t27Z5bUtPT9eHH36of/7zn0pKSlJkZPOFkecijNyS0kuP+xhGsr4t1G3PfNbgc7+8eqDuueKCgPWxtZxyujT4kXe9ts2dPEh3T+hXr63LbeidLXm69+XsJo/55A8u1Hcv7BnQfp5L9778pf7zdZ7uGNNbA+Ki9MW+Y3rrq0Nmd8ujZ6cIXTGom4pOOPXOlqrTovdP7K8n61x2uXxaitKGdm/wGMdOOnXRb5qfkZh5aZJ+fd0QHTvpVKXbULfq0zrllS4FBwVp/ltb9eKnDX+ZfPVomhx+FJq2RM0Ueag96JyvceF2Gy1+zZPlleoQapfNZtPpCpe25ZWoX0xHvbs1TymJnRXfKUIRIXbLzDRWutxyGYb2F5XpZy99qempibokqYtyj57SqQqX/v7pfm3Ye9QTrLtGhur9X1ymvOLTSujcQR3C7Homc4/+8O5O/eSyvnpo0iAFBdlkGIYOl5TrtS9y9UTGmT8OvpfSS06XW//aVPXftT3IpvUPXanY6KqZp/JKl7Jzjqt3lw6K71R1RdC3R07osz1HFRUerP9uPyyXIS26aZgiw+r/0bl21xGt23VExacqtG7XERWUlqtnpwjZbNKBY6d0/8T+SknsrBXr9+mD7QX19jdba6yZ1WphZOXKlZo2bZqWLVum1NRULV++XM8884y2bt2qxMREzZ07VwcPHtSKFSsa3H/+/Plt5mqa2mHk5pG99MT3fQsj9aZe69i36NqA9K81Lfj3Nj33iff847MzRmni4LhG9qhy4YL3dbw6tQ+I6+g5tVDjm99NbpdXFO3IL9GkJb795frQ5EHK2HZYG/cfC2gfPp07UTabdN1fPm7wyoy6/jp9lK4aEqfDJaf19No9mjCwm881S+9uyVOZ06XiUxW6fGCs+nTtoG+PnNRj/96quy/rp9R+XZv9y7zMWamwYLuOnnTKHmTTXz7cre+lJGhIfOD+GwVquNxGi2eLAnUKJJAMw9DG/cf0n6/z9E3BCQ3uEaUN+47pq+pZwRrR4cEqOe17bdQNI+L1+5uG6Yt9R1V4wqlPvinUyN6ddMeYxAZDrtttyOlya8Peo7qsFWoeW6WAVZKmTp2qoqIiLViwQHl5eUpOTtbq1auVmJgoScrLy1NOTv1Fc9o6f1ZgrVu41N4YhlEviEjSAB8KeD97eKLKK92KDq/6y/epNd/oj++dWXPlkbe26vc3DgtcZ1vZ4ZLTumVZlnKPnmq0TUpiZ6/gMWtCP919WV89/8k+de0YqksviNEN//eJ55zwoO5ReuXHY9SpQ4hsNpsqXG59feC43tt6WMvX7WnwNbYvmKSI0Kqp/k/nTpTLbeiB177Sv5uYmbliUKwkKS46XI9cP8Sv9z0puUe9bRfEdtSLd432+Rg1pyNrZk0evX6oX30A/HE2p63aWhCRqmovR/XpolF9fL+U1jAMrd9TpMzdhYrpGKYBcR11cZ+qCwr61Fl+4fKBVf8+3NLMaZegIJvCg+ytEkT84ffMiBlaa2bk4PFTGlc9M3LTRT21eOqFPu33ZvZBzV65SeMu6KpPvql/Fcrm+WmKCm/daeqzUVB6Wpf87r+SpMSuHbTwxmEqPlWhycPqf0H5Ivdomcb/4UwNw5bHrlbHBqYwzdRQkXVD9Rq16yQk6V/3jNOIhE7acrBYNpuarIvZlHtcD636Wi/eNdrzBd2YfYUnVXSyXCmJTf9DdPSkU+WVLsVGheuP7+3UyfJKvbIhRy/NHM0tCAC0ea02M3K+8ieR1cyMRDRStPZVbnGbXo11z5EzX7Zrf3nFWR8voUsHvTt7vOc0R/Kj7+lnl/dTTMcw3XlpUjN7B17p6Qpl7i7U0Pho9e7SQRcuyFDxqTMFYb+aNFA9O0Xo/lc31dv3ndnjFRwUVO+vsOSezRfnXpjQSe/OvsynPvaJiaz3l0xDutRajv+hyYMkSb+ZkuzTawBAe0EYqebPBFFNGAlrJIyUV7bt0zh7q//yD+SaKIO6eyfe9I+q1m9Z8J+qAuZ4R7imj+2jWXUKZLNzjunG9Cz9atJADevp0NcHinXDiHgt+WC3Rvftou+P8u+S7vJKl4bNf7/JNn94d2e9bT+/8gKl9OnCfTUAwASEkWq+RpGC0tOeKyzCgoP0+PdG6MHXvtL1I+I95/f/+N5OXTkots1WxO85UlV02rdbYJd4/9udl2jGcxsafO5Q8WktemeHhsZHa3z/qhBkGIZurL5EunZAqKlBWfXlAV3Wv5tPayw0dYlsc7IeutJTOQ8AOPcII9V8nRi54S+fKL/6/hrhIXbdktJLaUPjFB5s94SRHfmleuzf2zT/hrZX0GcYhp7JrCpeDfT9ZiYM6KZtC67WkEcaX5dk2rMbdP2IeHWNDNVFvTs1e8x/fJGrn0/s3+jzqzYeUObuI5owsOlZngfTBuiC2I4KsQfprr9VLeo1vJdD/7pnXJsNjQBgFZYOI7VPzfg6M1ITRCQpvHpKv+bKkqmjErTyi1xJ0gtZ+9pcGKm7PkrXyKaLLFuiQ2iwti24Wv/ceECP/Kv+zQQleULbC40s8Frb4oxdumJgrIb18q7ZeGdznn760pee39/c5H3Vyc7fTlJYsF1lzkoVnXB6FgmS2sel1wBgJZYOI7X5UjNStxYkPMT7cjFHB+8raK55MlP/ue/Sc74oU10b9x/T9Gc/q7dKYNrQptcUaakOocGantpHt17SW8fLKtSpQ4jKyl0asaDhWo7fTEnW4vd36nSFWy/86GLFRYeruyNcg/6nalG26//vY/1oXB/NHN9X678tkiMixCuI1Pa7G5N168W9PWPeITRYHbrwMQeAtox/pav5MjNSXun2+r3uEtBhda5l35ZXouc+2auZ4/uebffOSmP3mAlp5cXJQuxBnktcHR2CtOyOkZr19/oh4uohcZo2JrHe9l9ePdBTP/L8J/v0/Cf7mn3NG0bEmx7+AAD+aXsrwZjFhzTirBNG6oaPur9L0m/f3u5XN46UluvJD3Yrv/h0843Pwvq5zd8TKNAmJffQnt9fo32LrtXfqxfX+l5KL89SzHX5sqz+hw9M0N6F1+iR64boL7de1KbXdwEANMzSYaT2mZm3N+cpO6fp5b1rr88hqd6y54FY5e+hVV/rTx/s0o99uXOqD040cIv1b39/jXo4zLl6pGbW4tL+Mdrxm0n6wy3Dm2z/9s8vbfS5ft0i1bdbR9lsNt15aZKuHxEf0L4CAM4NTtPUcmN6VpPFjd9/er3X7y6390yJLwtjNee/O6punrT5YDP31PbR/iLvAPWHW4a3mbuB+nK76qHxDm157Gqdcrq063CpnK6qMV+zo0APXzO4tbsIADgHCCNnocLlfW5nbL8YLf7+CK/btI/o5V9AcUSEeK0WerZyisqq+pHQSf+6Z1zAjnsudQwLVsewYK8l1q+ovu8CAKD9s/RpmrNV4XLX23bTSO+bEn11oFiHS3yv/6h96/WGTrH4w+U2PFedxDVzrxQAAMxCGDkLLnfDVa9rHrxc0eFnJp3+990dPh2voOS0co6WeX7fW6dGpSkrP89R5u4jnt/LK116vtadefNauSAWAICWIoychZtHNnxr5qSYSG2Yd5Xn99e/PFjvSpyG/G6195U3ewpP+NSPlz7br/+3arOmPbtBuUfLNPnJTA389bteV/I8kDbAp2MBAHCuEUZ85K4zC/LVI2lN3nW1bnFm+kffNPsaXx/wLlr9tsC3MDLvjS2en8f/YY2255V4Pf+dIXG6nBoLAEAbRRjxkbNOfUjd1VYb0qPWDd5e/iyn2fY1d9Ot8a0fp2maQrEnAKAtI4z4qHYYeWnmaJ/2+cV3zpwaKSgtb7LtzvxSz8/9qu+m++2R5mdGGqtbqa2TD8EJAACzWDqM+HqnXsl79dWx/br6tE9ErVM1Q3pEa3/RyUbvgbO3Vn3IDSN6Vm872WjYMAxDBSWn9cqG5mdcLm/mjrYAAJiJdUZ8VBNGQu1BPt9y/pKkLp6ft+WVaMIfP9KC7w7V9NQ+9drWXrNkaHy0Qu1BKq9069DxU153nDUMQzabTXf97Qt9WL1AWo3fTEnW/7xZVT+yZOqFmnJRT5/fHwAAZrH0zIg/asJIiN331UvjosP19LQUr22P/Gur1yzL+m+LNOWpT7wuy71yUKz6xFQFkCUf7PbMpuzML1XS3NVa+M72ekFEkiYN7e75eeJg6kQAAO0DYaSOZWu/VW6ttT5q1Cxw5u/9Zy7u06XetgG/fkdPr/1WhmFoxnMbtCn3uP7xxQFJ0m2jeysoyKa+MR0lSau+PKD3th6WJF29ZJ0k6em1e+odMy46TN2iwrRk6oX609QR3DAOANBuWDqMGA3cqnfROzt03V8+rrf9jeyDkqRjZf4t1d65keLRhe/s0Ltb8utdpdM1MlSS5K5VW/LIv7aoOet+dYUkacpFPXXjRQ2vfwIAQFtk6TDSmIbuDZP+0bctOlZT9SU1S7XX1rlDVRjpXatOpKC0XH/NrD8b4unb7SMVFtz8TecAAGiLCCNtTNeOVWFk1uX9vLbXXk21tjvG9FbakLhW7xcAAK2FMNLG1MyMxHQMU2b1qZfGPHbDUP12yjAF2/m/EQDQfln6W8yfdUbOxot3XeJz2y7VNSOSlNClg0Yn1S+ArXHDiPiz6hcAAG2BpcPIuZLat6v6dO3gWVm1KTWnaWrUXe31vw9M8PzMyqoAgPMBYeQcCLYHKWPOBL1z/2XNtq05TVN735q1Su6f2F/9unXUyp+M0X/uu9TnxdcAAGjLCCPnSIg9SKHBQbpjTG9J0hPfG+F57tphPSRJkaH2enf7laSrh3bXV4+kafZV/SVJo/t2VXJPxznoNQAArY8w4qPu0VV34P3DLcPP6jiP3ZCsdb+8Qjen9NK1w3uob7dI3ZJStS5ITFRYo/s5OoQwEwIAOC9Z+t40/tSv2oOqgsCg7lFn9Zr2IJt6d61aQ+Sp20bKMAy5DemuS5MaXK0VAIDznaXDiD9qVkoNCfBltDabTXab9D/XDQnocQEAaC84TeOjilYKIwAAWB3frD6qudNuKGEEAICAsvQ3q+HHqmeemZFgikgBAAgkS4cRXxmGoQpXVXDhNA0AAIHFN2sj1u46opc+2y9JniAiEUYAAAg0rqZpxIznNkiS+nSN1IUJnTzbw4IJIwAABJKlv1l9qRj59sgJT72IxMwIAACBxjdrMypchmeNkSDbmcXPAABAYBBGmlHpclO8CgBAK+LbtRmVboM1RgAAaEV8uzajwuWutcYIwwUAQKBZ+tvVlzXPKlxubco9Lkk6etLZuh0CAMCCLB1GfFHpNvSrf35tdjcAADhvEUaaUenyfcl4AADgP8JIM2qvMQIAAALP4mGk+VmPCmZGAABoVRYPI82rZGYEAIBWRRhpRqWbmREAAFoTYaQZ1IwAANC6CCPNqB1Gfnn1QBN7AgDA+cnSYcSXRc/KK926ILajJOmi3p1at0MAAFiQpcOIL05XuDxFrNwoDwCAwOPbtRllTpf2FZVJIowAANAa+HZtxtcHij0/BwfZTOwJAADnpxaFkfT0dCUlJSk8PFwpKSnKzMxstO3HH3+scePGqWvXroqIiNCgQYP0pz/9qcUdDiR/L9oN5a69AAAEXLC/O6xcuVKzZ89Wenq6xo0bp6efflqTJ0/Wtm3b1Lt373rtIyMjde+992r48OGKjIzUxx9/rLvvvluRkZH6yU9+EpA3ca4wMwIAQODZDMOXa0rOGD16tEaOHKmlS5d6tg0ePFhTpkzRwoULfTrGTTfdpMjISL344os+tS8pKZHD4VBxcbGio6P96W6Tdh0uVdqf1vncPvNXVyihS4eAvT4AAOczX7+//Trv4HQ6tXHjRqWlpXltT0tLU1ZWlk/HyM7OVlZWliZMmNBom/LycpWUlHg92gIKWAEACDy/vl0LCwvlcrkUFxfntT0uLk75+flN7turVy+FhYVp1KhRuueeezRz5sxG2y5cuFAOh8PzSEhI8KebPvNvTkgKtnOaBgCAQGvRn/o2m/eXsmEY9bbVlZmZqS+++ELLli3TkiVL9MorrzTadu7cuSouLvY8cnNzW9LNgHP7m14AAECz/CpgjYmJkd1urzcLUlBQUG+2pK6kpCRJ0rBhw3T48GHNnz9ft956a4Ntw8LCFBYW5k/XzoluHdtenwAAaO/8mhkJDQ1VSkqKMjIyvLZnZGRo7NixPh/HMAyVl5f789KmGxgX1ezsDwAA8J/fl/bOmTNH06ZN06hRo5Samqrly5crJydHs2bNklR1iuXgwYNasWKFJOmpp55S7969NWjQIElV6448/vjjuu+++wL4Nlrfkh9caHYXAAA4L/kdRqZOnaqioiItWLBAeXl5Sk5O1urVq5WYmChJysvLU05Ojqe92+3W3LlztXfvXgUHB6tfv35atGiR7r777sC9ixYy/Fj2bHCPwF1SDAAAzvB7nREztNY6IzvySzRpSeOrx9a2b9G1AXtdAACsoFXWGQEAAAg0wggAADCVpcNIYyeoRiR0Oqf9AADAyiwdRhozfUyifndjsud37tYLAEDr4Vu2AUFB0u2jE5WS2FmS9NgNQ03uEQAA5y+/L+21Ape76n9fvOsSbc8r1UWctgEAoNVYOow0WjPSyyFJ6hAa7JkdAQAArcPSYaSul2aOVlR4sPrHRZndFQAALIMwUktcdJguiCWIAABwLlHAWkvbX4sWAIDzD2GkFrIIAADnnqXDSN0b5fXsFGFSTwAAsC5Lh5Ea4SFB+uLXVykyjBIaAADONcKIJEdEiGI6hpndDQAALIkwAgAATGXpMMLVMwAAmM/SYaSGTTazuwAAgGURRgAAgKkIIwAAwFSEEQAAYCrCiCQbJSMAAJiGMAIAAExFGAEAAKYijAAAAFNZOoyw6BkAAOazdBipQf0qAADmIYwAAABTEUYAAICpLB1GDFE0AgCA2SwdRmrYWPUMAADTEEYAAICpCCMAAMBUhBEAAGAqS4cRFj0DAMB8lg4jAADAfIQRAABgKsIIAAAwlaXDCCUjAACYz9JhpAZrngEAYB7CCAAAMBVhBAAAmMrSYcRgoREAAExn6TBSg5oRAADMQxgBAACmIowAAABTEUYAAICpLB1GKF8FAMB8lg4jNWyighUAALMQRgAAgKkIIwAAwFSWDiOseQYAgPksHUZqsOgZAADmIYwAAABTEUYAAICpLB5GKBoBAMBsFg8jVSgZAQDAPC0KI+np6UpKSlJ4eLhSUlKUmZnZaNvXX39d3/nOd9StWzdFR0crNTVV7733Xos7DAAAzi9+h5GVK1dq9uzZmjdvnrKzszV+/HhNnjxZOTk5DbZft26dvvOd72j16tXauHGjrrjiCl1//fXKzs4+684DAID2z2YY/q22MXr0aI0cOVJLly71bBs8eLCmTJmihQsX+nSMoUOHaurUqXrkkUd8al9SUiKHw6Hi4mJFR0f7090mbdx/VDcvXa8+XTvoo19eEbDjAgAA37+//ZoZcTqd2rhxo9LS0ry2p6WlKSsry6djuN1ulZaWqkuXLo22KS8vV0lJidejNbDoGQAA5vMrjBQWFsrlcikuLs5re1xcnPLz8306xhNPPKGTJ0/q+9//fqNtFi5cKIfD4XkkJCT4002/2Vj1DAAA07SogLXul7dhGD59ob/yyiuaP3++Vq5cqdjY2EbbzZ07V8XFxZ5Hbm5uS7oJAADagWB/GsfExMhut9ebBSkoKKg3W1LXypUrddddd+m1117TVVdd1WTbsLAwhYWF+dM1AADQTvk1MxIaGqqUlBRlZGR4bc/IyNDYsWMb3e+VV17RD3/4Q7388su69tprW9bTVkDJCAAA5vNrZkSS5syZo2nTpmnUqFFKTU3V8uXLlZOTo1mzZkmqOsVy8OBBrVixQlJVEJk+fbqefPJJjRkzxjOrEhERIYfDEcC30nJUjAAAYB6/w8jUqVNVVFSkBQsWKC8vT8nJyVq9erUSExMlSXl5eV5rjjz99NOqrKzUPffco3vuucezfcaMGXrhhRfO/h0AAIB2ze91RszQWuuMfL7vqL63bL36xkTqwwcvD9hxAQBAK60zcr5p+zEMAIDzn6XDiAdFIwAAmIYwAgAATEUYAQAApiKMAAAAU1k6jLSDC4kAADjvWTqM1KB+FQAA8xBGAACAqQgjAADAVJYOI1SMAABgPkuHkRo2G1UjAACYhTACAABMRRgBAACmIowAAABTWTqMsOYZAADms3QYqUH5KgAA5iGMAAAAUxFGAACAqSwdRgyWPQMAwHSWDiM1WPMMAADzEEYAAICpCCMAAMBU1g4jlIwAAGA6a4eRajZWGgEAwDSEEQAAYCrCCAAAMBVhBAAAmMrSYYT6VQAAzGfpMFKDRc8AADAPYQQAAJiKMAIAAExl6TBiUDQCAIDpLB1GAACA+QgjAADAVIQRAABgKkuHEYOVRgAAMJ2lw0gNGwuNAABgGsIIAAAwFWEEAACYijACAABMZekwwqJnAACYz9JhpAblqwAAmIcwAgAATEUYAQAAprJ0GKFkBAAA81k6jNRgzTMAAMxDGAEAAKYijAAAAFNZOowYLDQCAIDpLB1GalAzAgCAeQgjAADAVIQRAABgKsIIAAAwlaXDCOWrAACYz9JhpIaNW+UBAGAawggAADBVi8JIenq6kpKSFB4erpSUFGVmZjbaNi8vT7fddpsGDhyooKAgzZ49u6V9BQAA5yG/w8jKlSs1e/ZszZs3T9nZ2Ro/frwmT56snJycBtuXl5erW7dumjdvnkaMGHHWHQ4oikYAADCd32Fk8eLFuuuuuzRz5kwNHjxYS5YsUUJCgpYuXdpg+z59+ujJJ5/U9OnT5XA4zrrDrYFFzwAAMI9fYcTpdGrjxo1KS0vz2p6WlqasrKyAdaq8vFwlJSVeDwAAcH7yK4wUFhbK5XIpLi7Oa3tcXJzy8/MD1qmFCxfK4XB4HgkJCQE7NgAAaFtaVMBqq3NewzCMetvOxty5c1VcXOx55ObmBuzYAACgbQn2p3FMTIzsdnu9WZCCgoJ6syVnIywsTGFhYQE7XmMMKlgBADCdXzMjoaGhSklJUUZGhtf2jIwMjR07NqAdO5eoXwUAwDx+zYxI0pw5czRt2jSNGjVKqampWr58uXJycjRr1ixJVadYDh48qBUrVnj22bRpkyTpxIkTOnLkiDZt2qTQ0FANGTIkMO8CAAC0W36HkalTp6qoqEgLFixQXl6ekpOTtXr1aiUmJkqqWuSs7pojF110kefnjRs36uWXX1ZiYqL27dt3dr0HAADtnt9hRJJ+9rOf6Wc/+1mDz73wwgv1thlG26zNaKPdAgDAUrg3jcSqZwAAmIgwAgAATEUYAQAAprJ0GKFmBAAA81k6jNSgYgQAAPMQRgAAgKkIIwAAwFSEEQAAYCpLhxHqVwEAMJ+lw0gN1jwDAMA8hBEAAGAqwggAADCVpcNIW72BHwAAVmLpMFKDkhEAAMxDGAEAAKYijAAAAFNZOoxQMQIAgPksHUZq2FhoBAAA0xBGAACAqQgjAADAVIQRAABgKkuHEdY8AwDAfJYOIzUoXwUAwDyEEQAAYCrCCAAAMJXFwwhFIwAAmM3iYaQKa54BAGAewggAADAVYQQAAJjK0mGEdUYAADCfpcNIDRsrjQAAYBrCCAAAMBVhBAAAmIowAgAATGXpMEL9KgAA5rN0GPGgfhUAANMQRgAAgKkIIwAAwFSWDiMsegYAgPksHUZqUDICAIB5CCMAAMBUhBEAAGAqwggAADCVpcOIwbJnAACYztJhpIaNClYAAExDGAEAAKYijAAAAFNZOoyw6BkAAOazdBipYWPZMwAATEMYAQAApiKMAAAAU1k6jFAyAgCA+SwdRmqwzggAAOYhjAAAAFMRRgAAgKkIIwAAwFQtCiPp6elKSkpSeHi4UlJSlJmZ2WT7tWvXKiUlReHh4erbt6+WLVvWos4GmsGqZwAAmM7vMLJy5UrNnj1b8+bNU3Z2tsaPH6/JkycrJyenwfZ79+7VNddco/Hjxys7O1sPP/ywfv7zn2vVqlVn3flAoYAVAADz+B1GFi9erLvuukszZ87U4MGDtWTJEiUkJGjp0qUNtl+2bJl69+6tJUuWaPDgwZo5c6buvPNOPf7442fdeQAA0P75FUacTqc2btyotLQ0r+1paWnKyspqcJ/169fXa3/11Vfriy++UEVFRYP7lJeXq6SkxOvRGtbuOtIqxwUAAL7zK4wUFhbK5XIpLi7Oa3tcXJzy8/Mb3Cc/P7/B9pWVlSosLGxwn4ULF8rhcHgeCQkJ/nTTZ6H2qrffMSy4VY4PAACa16ICVludIgvDMOpta659Q9trzJ07V8XFxZ5Hbm5uS7rZrOtHxOv+if01d/LgVjk+AABonl9TAjExMbLb7fVmQQoKCurNftTo3r17g+2Dg4PVtWvXBvcJCwtTWFiYP11rkXEXxGjcBTGt/joAAKBxfs2MhIaGKiUlRRkZGV7bMzIyNHbs2Ab3SU1Nrdf+/fff16hRoxQSEuJndwEAwPnG79M0c+bM0V//+lc999xz2r59u37xi18oJydHs2bNklR1imX69Ome9rNmzdL+/fs1Z84cbd++Xc8995yeffZZPfjgg4F7FwAAoN3yu3Jz6tSpKioq0oIFC5SXl6fk5GStXr1aiYmJkqS8vDyvNUeSkpK0evVq/eIXv9BTTz2l+Ph4/fnPf9bNN98cuHcBAADaLZvRDpYhLSkpkcPhUHFxsaKjo83uDgAA8IGv39/cmwYAAJiKMAIAAExFGAEAAKYijAAAAFMRRgAAgKkIIwAAwFSEEQAAYCrCCAAAMBVhBAAAmMrv5eDNULNIbElJick9AQAAvqr53m5usfd2EUZKS0slSQkJCSb3BAAA+Ku0tFQOh6PR59vFvWncbrcOHTqkqKgo2Wy2gB23pKRECQkJys3N5Z43PmC8fMdY+Y6x8h1j5TvGynetOVaGYai0tFTx8fEKCmq8MqRdzIwEBQWpV69erXb86OhoPqx+YLx8x1j5jrHyHWPlO8bKd601Vk3NiNSggBUAAJiKMAIAAExl6TASFhamRx99VGFhYWZ3pV1gvHzHWPmOsfIdY+U7xsp3bWGs2kUBKwAAOH9ZemYEAACYjzACAABMRRgBAACmIowAAABTWTqMpKenKykpSeHh4UpJSVFmZqbZXTqn5s+fL5vN5vXo3r2753nDMDR//nzFx8crIiJCl19+ubZu3ep1jPLyct13332KiYlRZGSkbrjhBh04cOBcv5VWsW7dOl1//fWKj4+XzWbTm2++6fV8oMbn2LFjmjZtmhwOhxwOh6ZNm6bjx4+38rsLrObG6oc//GG9z9qYMWO82lhhrBYuXKiLL75YUVFRio2N1ZQpU7Rz506vNnyuqvgyVnyuzli6dKmGDx/uWbgsNTVV77zzjuf5Nv+5Mizq1VdfNUJCQoxnnnnG2LZtm3H//fcbkZGRxv79+83u2jnz6KOPGkOHDjXy8vI8j4KCAs/zixYtMqKiooxVq1YZmzdvNqZOnWr06NHDKCkp8bSZNWuW0bNnTyMjI8P48ssvjSuuuMIYMWKEUVlZacZbCqjVq1cb8+bNM1atWmVIMt544w2v5wM1PpMmTTKSk5ONrKwsIysry0hOTjauu+66c/U2A6K5sZoxY4YxadIkr89aUVGRVxsrjNXVV19tPP/888aWLVuMTZs2Gddee63Ru3dv48SJE542fK6q+DJWfK7OeOutt4y3337b2Llzp7Fz507j4YcfNkJCQowtW7YYhtH2P1eWDSOXXHKJMWvWLK9tgwYNMh566CGTenTuPfroo8aIESMafM7tdhvdu3c3Fi1a5Nl2+vRpw+FwGMuWLTMMwzCOHz9uhISEGK+++qqnzcGDB42goCDj3XffbdW+n2t1v2ADNT7btm0zJBmffvqpp8369esNScaOHTta+V21jsbCyHe/+91G97HqWBUUFBiSjLVr1xqGweeqKXXHyjD4XDWnc+fOxl//+td28bmy5Gkap9OpjRs3Ki0tzWt7WlqasrKyTOqVOXbv3q34+HglJSXpBz/4gfbs2SNJ2rt3r/Lz873GKCwsTBMmTPCM0caNG1VRUeHVJj4+XsnJyef9OAZqfNavXy+Hw6HRo0d72owZM0YOh+O8G8OPPvpIsbGxGjBggH784x+roKDA85xVx6q4uFiS1KVLF0l8rppSd6xq8Lmqz+Vy6dVXX9XJkyeVmpraLj5XlgwjhYWFcrlciouL89oeFxen/Px8k3p17o0ePVorVqzQe++9p2eeeUb5+fkaO3asioqKPOPQ1Bjl5+crNDRUnTt3brTN+SpQ45Ofn6/Y2Nh6x4+NjT2vxnDy5Ml66aWX9OGHH+qJJ57Q559/riuvvFLl5eWSrDlWhmFozpw5uvTSS5WcnCyJz1VjGhoric9VXZs3b1bHjh0VFhamWbNm6Y033tCQIUPaxeeqXdy1t7XYbDav3w3DqLftfDZ58mTPz8OGDVNqaqr69eunv/3tb54isJaMkZXGMRDj01D7820Mp06d6vk5OTlZo0aNUmJiot5++23ddNNNje53Po/Vvffeq6+//loff/xxvef4XHlrbKz4XHkbOHCgNm3apOPHj2vVqlWaMWOG1q5d63m+LX+uLDkzEhMTI7vdXi/JFRQU1EuOVhIZGalhw4Zp9+7dnqtqmhqj7t27y+l06tixY422OV8Fany6d++uw4cP1zv+kSNHzusx7NGjhxITE7V7925J1hur++67T2+99ZbWrFmjXr16ebbzuaqvsbFqiNU/V6Ghobrgggs0atQoLVy4UCNGjNCTTz7ZLj5XlgwjoaGhSklJUUZGhtf2jIwMjR071qRema+8vFzbt29Xjx49lJSUpO7du3uNkdPp1Nq1az1jlJKSopCQEK82eXl52rJly3k/joEan9TUVBUXF2vDhg2eNp999pmKi4vP6zEsKipSbm6uevToIck6Y2UYhu699169/vrr+vDDD5WUlOT1PJ+rM5obq4ZY9XPVGMMwVF5e3j4+V2dV/tqO1Vza++yzzxrbtm0zZs+ebURGRhr79u0zu2vnzAMPPGB89NFHxp49e4xPP/3UuO6664yoqCjPGCxatMhwOBzG66+/bmzevNm49dZbG7wUrFevXsYHH3xgfPnll8aVV1553lzaW1paamRnZxvZ2dmGJGPx4sVGdna25/LvQI3PpEmTjOHDhxvr16831q9fbwwbNqzdXVbY1FiVlpYaDzzwgJGVlWXs3bvXWLNmjZGammr07NnTcmP105/+1HA4HMZHH33kdTlqWVmZpw2fqyrNjRWfK29z58411q1bZ+zdu9f4+uuvjYcfftgICgoy3n//fcMw2v7nyrJhxDAM46mnnjISExON0NBQY+TIkV6XjFlBzXXmISEhRnx8vHHTTTcZW7du9TzvdruNRx991OjevbsRFhZmXHbZZcbmzZu9jnHq1Cnj3nvvNbp06WJEREQY1113nZGTk3Ou30qrWLNmjSGp3mPGjBmGYQRufIqKiozbb7/diIqKMqKioozbb7/dOHbs2Dl6l4HR1FiVlZUZaWlpRrdu3YyQkBCjd+/exowZM+qNgxXGqqExkmQ8//zznjZ8rqo0N1Z8rrzdeeednu+zbt26GRMnTvQEEcNo+58rm2EYxtnNrQAAALScJWtGAABA20EYAQAApiKMAAAAUxFGAACAqQgjAADAVIQRAABgKsIIAAAwFWEEAACYijACAABMRRgBAACmIowAAABTEUYAAICp/j9J952PUkKopAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot([i for i in range(1,n+1)],frequent_list,[0.4 for i in range(n)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.4096$"
      ],
      "text/plain": [
       "0.409600000000000"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(5,4)*0.8**4*0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6912.0"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9600/25*18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if(a==b):\n",
    "    print(\"OK\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 167$"
      ],
      "text/plain": [
       "167"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "170*Rational(2,3)+161*Rational(1,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Data([29,31,30,32,28])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30.0"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.0$"
      ],
      "text/plain": [
       "2.00000000000000"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.variance(sample=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Data([27,44,40,31,43])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37.0"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 46.0$"
      ],
      "text/plain": [
       "46.0000000000000"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.variance(sample=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test=[Data([1,2,3]),Data([2,4,5]),Data([2,6,3]),Data([2,5,8])]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\2 & 4 & 5\\\\2 & 6 & 3\\\\2 & 5 & 8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 2, 3],\n",
       "[2, 4, 5],\n",
       "[2, 6, 3],\n",
       "[2, 5, 8]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix(test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & 2 & 2 & 2\\\\2 & 4 & 6 & 5\\\\3 & 5 & 3 & 8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 1, 1, 1],\n",
       "[1, 2, 2, 2],\n",
       "[2, 4, 6, 5],\n",
       "[3, 5, 3, 8]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([[ones(1,4)],[Matrix(test).T]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 1 & 2 & 3\\\\1 & 2 & 4 & 5\\\\1 & 2 & 6 & 3\\\\1 & 2 & 5 & 8\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 1, 2, 3],\n",
       "[1, 2, 4, 5],\n",
       "[1, 2, 6, 3],\n",
       "[1, 2, 5, 8]])"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "AT=A.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(AT*A).rank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1, 0, 0, 0],\n",
       "[0, 1, 0, 0],\n",
       "[0, 0, 1, 0],\n",
       "[0, 0, 0, 1]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(AT*A).inv()*(AT*A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3]"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(Matrix(Data([2,3])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 吉安高一上学期期末"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=solveset(abs(2*x+3)<2,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(- \\frac{5}{2}, - \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Interval.open(-5/2, -1/2)"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=solveset(3**x>Rational(1,9),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-2, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval.open(-2, oo)"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-2, - \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Interval.open(-2, -1/2)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Intersection(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(1,-a,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a x + x^{2} + 10$"
      ],
      "text/plain": [
       "-a*x + x**2 + 10"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 19 - 3 a$"
      ],
      "text/plain": [
       "19 - 3*a"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.equation(x).subs(x,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 10 - \\frac{a^{2}}{4}$"
      ],
      "text/plain": [
       "10 - a**2/4"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.extreme_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269e279a50>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Abs(x**3),2**x,(x,-2,-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269e702650>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Abs(x**3),2**x,(x,0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269e727e10>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Abs(x**3),2**x,(x,8,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269e709cd0>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Abs(x**3),2**x,(x,9,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269e1271d0>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(Abs(x**3),2**x,(x,1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 9.44483117612978$"
      ],
      "text/plain": [
       "9.44483117612978"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N((2-log(75,10))/(2-log(97,10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 房子改汽车折旧率要发生变化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3.45018615150574$"
      ],
      "text/plain": [
       "3.45018615150574"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N((2-log(75,10))/(2-log(92,10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.96378782734556$"
      ],
      "text/plain": [
       "1.96378782734556"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(log(92,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.472222222222219"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2-1.875)/(2-1.964)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.615384615384615"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "125/13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*x**2-8*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{2} - 8 x$"
      ],
      "text/plain": [
       "2*x**2 - 8*x"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2be5f2dcd90>"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,0,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{2} + 6 x + 16$"
      ],
      "text/plain": [
       "x**2/2 + 6*x + 16"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(function_transfer(expr,x,move=-8)/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-7, -5\\right\\}$"
      ],
      "text/plain": [
       "{-7, -5}"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_+Rational(3,2),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_f=floor(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\lfloor{x}\\right\\rfloor$"
      ],
      "text/plain": [
       "floor(x)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_g=k*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle k x$"
      ],
      "text/plain": [
       "k*x"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2269eab2050>"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr_f,0.5*x,(x,-3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(1/a+3/b)*(a+2*b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 a}{b} + 7 + \\frac{2 b}{a}$"
      ],
      "text/plain": [
       "3*a/b + 7 + 2*b/a"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=Data([0,1,2,3,3,4,6,6,7,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6.4$"
      ],
      "text/plain": [
       "6.40000000000000"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.variance(sample=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=Data([2,3,3,4,6,6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2.33333333333333$"
      ],
      "text/plain": [
       "2.33333333333333"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.variance(sample=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 3, 5, 9, 9]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data*2-3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=ln(x)/x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{\\log{\\left(x \\right)} - 1}{x^{2}}$"
      ],
      "text/plain": [
       "-(log(x) - 1)/x**2"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(1,a,-2*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x - 2 a + x^{2}$"
      ],
      "text/plain": [
       "a*x - 2*a + x**2"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a \\left(- a - 8\\right)}{4}$"
      ],
      "text/plain": [
       "a*(-a - 8)/4"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.extreme_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,x2=q.roots.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a}{2} - \\frac{\\sqrt{a \\left(a + 8\\right)}}{2}$"
      ],
      "text/plain": [
       "-a/2 - sqrt(a*(a + 8))/2"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{a}{2} + \\frac{\\sqrt{a \\left(a + 8\\right)}}{2}$"
      ],
      "text/plain": [
       "-a/2 + sqrt(a*(a + 8))/2"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{e \\left(-1 + 2 e\\right)}\\right\\}$"
      ],
      "text/plain": [
       "{exp(-1)/(-1 + 2*E)}"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x2-exp(-1),a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{2}{-1 + 2 e}, e^{-1}\\right\\}$"
      ],
      "text/plain": [
       "{-2/(-1 + 2*E), exp(-1)}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(q.equation(x).subs(a,list(solveset(x2-exp(-1),a,Reals))[0]),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a}{2} + \\frac{\\sqrt{a^{2} + 8 a}}{2} + 2$"
      ],
      "text/plain": [
       "a/2 + sqrt(a**2 + 8*a)/2 + 2"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(x1**2/a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4$"
      ],
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expand(x2**2/a)*expand(x1**2/a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=a+1/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a + \\frac{1}{a}$"
      ],
      "text/plain": [
       "a + 1/a"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{5} + 5 a^{3} + 10 a + \\frac{10}{a} + \\frac{5}{a^{3}} + \\frac{1}{a^{5}}$"
      ],
      "text/plain": [
       "a**5 + 5*a**3 + 10*a + 10/a + 5/a**3 + a**(-5)"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr**5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{3} + 3 a + \\frac{3}{a} + \\frac{1}{a^{3}}$"
      ],
      "text/plain": [
       "a**3 + 3*a + 3/a + a**(-3)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 724$"
      ],
      "text/plain": [
       "724"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(t**5-5*(t**3-3*t)-10*t).subs(t,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f6017e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "B=solveset((x-4)/(x-1)<=0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "724"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14*52-4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(1, 4\\right]$"
      ],
      "text/plain": [
       "Interval.Lopen(1, 4)"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[1, 2\\right)$"
      ],
      "text/plain": [
       "Interval.Ropen(1, 2)"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve_univariate_inequalities([x**2>=1,x**2<2*x,2*x<=4],x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=Data([0.004,0.014,a,0.022,0.02,a,0.008])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{0.016\\right\\}$"
      ],
      "text/plain": [
       "{0.016}"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(sum(data)*10-1,a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.044$"
      ],
      "text/plain": [
       "0.0440000000000000"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(data[-3::]).subs(a,0.016)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=Data([0.004,0.014,0.016,0.022,0.02,0.016,0.008])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "value_list=Data([5,15,25,35,45,55,65])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pmf=dict(zip(value_list,data*S(10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5: 0.0400000000000000,\n",
       " 15: 0.140000000000000,\n",
       " 25: 0.160000000000000,\n",
       " 35: 0.220000000000000,\n",
       " 45: 0.200000000000000,\n",
       " 55: 0.160000000000000,\n",
       " 65: 0.0800000000000000}"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pmf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a7072cc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 37.0$"
      ],
      "text/plain": [
       "37.0000000000000"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=FiniteRV(\"X\",pmf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.56$"
      ],
      "text/plain": [
       "0.560000000000000"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(X<=40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.76$"
      ],
      "text/plain": [
       "0.760000000000000"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "P(X<=50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cost=Piecewise((x**2-6*x+47,And(4<=x , x<12)),(15*x+324/x-93,And(12<=x,x<=27)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} x^{2} - 6 x + 47 & \\text{for}\\: x \\geq 4 \\wedge x < 12 \\\\15 x - 93 + \\frac{324}{x} & \\text{for}\\: x \\geq 12 \\wedge x \\leq 27 \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((x**2 - 6*x + 47, (x >= 4) & (x < 12)), (15*x - 93 + 324/x, (x >= 12) & (x <= 27)))"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sales=14*x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "profit=sales-cost-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2be61286c10>"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(profit,(x,4,27))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=sales-(15*x+324/x-93)-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - x + 90 - \\frac{324}{x}$"
      ],
      "text/plain": [
       "-x + 90 - 324/x"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 18$"
      ],
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(324)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 50 - \\left(x - 10\\right)^{2}$"
      ],
      "text/plain": [
       "50 - (x - 10)**2"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "QuadraticFunction(-1,S(20),-50).symmetry_equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 54$"
      ],
      "text/plain": [
       "54"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check.subs(x,18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(1,-(k+3),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + x \\left(- k - 3\\right) + 1$"
      ],
      "text/plain": [
       "x**2 + x*(-k - 3) + 1"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{k^{2}}{4} - \\frac{3 k}{2} + \\left(- \\frac{k}{2} + x - \\frac{3}{2}\\right)^{2} - \\frac{5}{4}$"
      ],
      "text/plain": [
       "-k**2/4 - 3*k/2 + (-k/2 + x - 3/2)**2 - 5/4"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.symmetry_equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-3, -1\\right)$"
      ],
      "text/plain": [
       "Interval.open(-3, -1)"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(q.extreme_value>0,k,Interval.open(-3,0))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check_q=QuadraticFunction(q.equation(x)+2*k*x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(1, 5\\right)$"
      ],
      "text/plain": [
       "Interval.open(1, 5)"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(check_q.delta<0,k,Reals)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=ln(x**2+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHTCAYAAACqbVU5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABcc0lEQVR4nO3deVxU5eIG8OfMwgwIDIKyiizijguLIuaW5tri1u6Spd3cKjNvpd1bt7o362ZlZe5LmplmmtkvK60U9wXFXRBEBRGURWZYZ5iZ8/sD4mZuqMA7y/P9fOYPDmfgYX94z3veV5JlWQYRERER2T2F6ABEREREVDtY7IiIiIgcBIsdERERkYNgsSMiIiJyECx2RERERA6CxY6IiIjIQbDYERERETkIFjsicniyLMNgMIDLdhKRo2OxIyKHV1RUBJ1Oh6KiItFRiIjqFIsdERERkYNgsSMiIiJyECx2RERERA6CxY6IiIjIQbDYERERETkIFjsiIiIiB8FiR0REROQgWOyIiIiIHASLHREREZGDYLEjIiIichAsdkREREQOgsWOiIiIyEGw2BERERE5CBY7IiIiIgfBYkdERETkIFjsiIiIiBwEix0RERGRg7C5YifLMj75NRUXC8tERyEiIiK6xsXCMnzyaypkWRYd5Ro2V+yW7jqHj389jYfm7EJSxhXRcYiIiIiqHTx/BQ/N2YWPfz2NZbvOiY5zDZsrdv3b+qGVvwfyio14bOFebEjKEh2JiIiICOsPXcATC/cir9iI1gGe6NfWT3Ska0iyDY4jlhjNmLLmMLacvAQAmNirGab1awmFQhKcjIjskcFggE6ng16vh6enp+g4RGRnLFYZH/ySgvkJZwAA/dr44ePHOqKBRiU42bVsstgBgNUq44PNKZi3zfY/iURk21jsiOhOFRvNmLI6Cb+eugwAmHxvBKb2bWGzg002W+z+sP7QBby27hhMFita+Xtg8VOxaNLQTXQsIrIjLHZEdCcyC0oxbnkiUi4VwUWlwAcPt8fgjkGiY92UzRc7oHKi4nNfJiKv2IRG7i5YMCoWMSENRcciIjvBYkdEt2v/2QKMX3kQBSUmNPbQYNHoWHQM9hId65Zs7uaJ64kJaYjvJ3dD6wBP5BWb8MTCvVh/6ILoWEREROSA1h28gBGL96KgxIR2QTpsnHyPXZQ6wE6KHQAEebni2/Hx6N/WDyaLFVO/OYL//pwMq9XmBxyJiIjIDlitMj7cnIKX1x5BhUXGwEh/fPNcPAJ0rqKj1ZhdXIr9M6tVxodbUvD51sqbKu5vH4APH+kArVopOBkR2SpeiiWiWymvsGDa2iP4v6PZAOx3RQ67K3Z/+PbgBUxffxQVFhnRTb2waHQsfNw1omMRkQ1isSOim8krNuLZFYlIyiiEWinhP0Pb4dHYYNGx7ojdFjsA2H0mD+O/PAhDuRnB3q5YNqYTInw9RMciIhvDYkdEN3L6UhGe+eIALlwpg85VjfkjYxDfzEd0rDtmN3Psrqdrs0ZYP/EeNPV2Q2ZBGYbN3Y3daXmiYxEREZEd2JGai+Fzd+PClTKE+rjhu4ld7brUAXZe7AAgwtcd303siuimXjCUmzF66X58k5gpOhYRERHZsFX7MjBm2QEUGc3oHOqN7ybeg/DG7qJj3TW7L3YA4OOuwapnu+CB9gEwW2W88u1RzPolhXfMEhER0VWsVhnv/ZSMGd8dg8UqY1h0EL4c1xkNG7iIjlYr7HqO3V9ZrTI+2nIac7amAQAeaB+AWbxjlsjpcY4dEQGA0WzBtLVH8cORiwCAqX1b4PneEZAk+7rz9WYcqtj94ZvETMxYfwxmq4zYkIZYNDrWYZo4Ed0+FjsiKiw14W9fHsT+swVQKST89+H2GBbdRHSsWucQl2L/6tHYYKwY2xkeWhUSz1/B8Pm7kVlQKjoWERERCZBZUIrh83Zj/9kCeGhUWP5MZ4csdYCDFjug8o7ZdRO6IkCnRXpuCYbN243jWXrRsYiIiKgeHb1QiKFzd+NMbgkCdFp8O6Er7oloJDpWnXHYYgcALfw88N3Ee9DK3wO5RUY8tmAPtp/OFR2LiIiI6sFvpy7hsQV7kVdsROsAT3w38R609Hfs9W4dutgBgL9Oi2/GxyM+3AclJgue+eIA1h28IDoWERER1aFV+zLw7IpElFVY0L15I3zzXBf467SiY9U5hy92AOCpVeOLZzrhoQ6BMFtlvLz2CD7fmgYHvG+EiIjIqcmyjI+3nMaM747BKgOPxjbB0jGd4KFVi45WL5yi2AGARqXE7Mc64rme4QCAD35JwT82HIeFa90RERE5BLPFihnfHcMnv6UCAF7o0xzvD28PtdJp6o5jLndyK1/sOou3/u8kZBm4r7UfPnsiCq4uXOuOyFFxuRMix1deYcHkVUn49dQlSBLwzuBIjOwSIjpWvXOeCvsnY+4Jw9wno+GiUuDXU5fw5OK9KCgxiY5FREREd6Cw1IQRi/fh11OX4KJSYN6IaKcsdYCTFjsAGNguAKvGxUHnqkZSRiEenr8bWYVlomMRERHRbbhYWIaH5+/BwfNX4KlVYeXYOAyIDBAdSxinLXYAEBvqjXUT4hFYtdbdw/N2I+1ykehYREREVAMpOUUYNnc30i4Xw99Ti7Xju6JzmLfoWEI5dbEDgAhfD3w7oSsifN2RrS/Hw/P3ICnjiuhYREREdBP7zxbgkfm7kWMoR4SvO9ZN7Orwa9TVhNMXOwAI9HLF2ufi0SHYC4WlFXhy0T4kcCFjolo3b948tG/fHp6envD09ER8fDx++umnmz4nISEBMTEx0Gq1CA8Px/z58+spLRHZqt+TL2HUkn0wlJsRE9IQ346PR5CXq+hYNoHFrkrDBi5YNS4O3Zs3QlmFBeOWH8DGIxdFxyJyKE2aNMF7772HxMREJCYmonfv3hg8eDBOnDhx3fPPnj2LQYMGoXv37khKSsKMGTPwwgsvYN26dfWcnIhsxYakLPxtxUEYzVb0aeWLlWPj4OXmIjqWzXDK5U5uxmS24uW1R/DDkYuQJOBfD7bFU11DRcciclje3t744IMPMHbs2Gte9+qrr2Ljxo04depU9bHx48fjyJEj2LNnT43fB5c7IXIMy3efw5sbK/8RHBoVhP8+7Fxr1NUEPxt/4aJS4JPHOmJ0fAhkGXhz4wl8tOU0d6kgqmUWiwWrV69GSUkJ4uPjr3vOnj170K9fv6uO9e/fH4mJiaioqLjh2zYajTAYDFc9iMh+ybKMT35NrS51Y7qG4sNHOrDUXQc/I9ehUEh466G2eOm+FgCAT39LxRvfn4CVu1QQ3bVjx47B3d0dGo0G48ePx3fffYc2bdpc99ycnBz4+flddczPzw9msxl5eXk3fB8zZ86ETqerfgQHB9fqx0BE9cdqlfH2/53Ex7+eBgBMua853nywDRQKSXAy28RidwOSJOHF+5rjnSGRkCTgy73nMW3tEZgtVtHRiOxay5YtcfjwYezduxcTJkzAU089hZMnT97wfEm6+pf3H6Pnfz3+Z9OnT4der69+ZGZm1k54IqpXZosV0749gmW7zgEA/vVgG0y5r8VNf/6dnUp0AFs3qksIPLUqTP3mCNYnZaHEZManT0RBo+IWZER3wsXFBREREQCA2NhYHDhwAJ988gkWLFhwzbn+/v7Iycm56tjly5ehUqng4+Nzw/eh0Wig0WhqNzgR1as/bxGmVEiY9Uh7DI1qIjqWzeOIXQ0M7hiE+SNj4KJS4JcTlzBueSJKTWbRsYgcgizLMBqN131dfHw8tmzZctWxzZs3IzY2Fmq1uj7iEZEAxUYzxizbj19PXYJGpcCCkTEsdTXEYldDfdv4YdmYTnBzUWJHah5GL9kPQ/mNJ28T0bVmzJiBHTt24Ny5czh27Bhef/11bNu2DSNGjABQeQl19OjR1eePHz8e58+fx9SpU3Hq1CksXboUS5YswbRp00R9CERUx/SlFRi5eB/2phfAXaPC8mc64742frd+IgFgsbst90Q0wpdj4+CpVSHx/BU8uWgv8ouvP9JARNe6dOkSRo0ahZYtW6JPnz7Yt28ffv75Z/Tt2xcAkJ2djYyMjOrzw8LCsGnTJmzbtg0dO3bEO++8g08//RTDhw8X9SEQUR3KKzbi8UV7cTizEF5uanz9bBd0Cb/xtAu6FtexuwMnLuoxesl+5JeYEOHrjpVj4+Cv04qORUQ3wHXsiGxfjr4cIxbvxZncEjRy1+CrcXHcIuwOcMTuDrQN1OGb8fEI0GmRdrkYjyzYjYz8UtGxiIiI7FJmQSkeXbAHZ3JLEKDT4pvnurDU3SEWuzvUrLE71o6PR4iPGzILyvDIgt04k1ssOhYREZFdSc8txqML9iCjoBRNvd3wzXPxCG/sLjqW3WKxuwtNGrph7XPxaOHnjksGIx5bsBepl4pExyIiIrILyTkGPLpgL7L15YjwrRwwCfZ2Ex3LrrHY3SVfTy2+frYLWgd4Vk76XLgXp7K5fREREdHNHM/S4/GFe5FXbESbAE+s+VsX+HlyvvrdYrGrBT7uGnz9bBzaBemQX2LCE4v24niWXnQsIiIim3QksxBPLtqLwtIKdAz2wtfPdoGPOxcVrw0sdrXEy80FK8fFoWOwFwpLK/Bk1e3aRERE9D+HMq5g5OJ9MJSbERvSEF+O7QydGxccry0sdrVI56rGl2M7IzakIQzlZoxcvA8HzxeIjkVERGQTEs8VYPSS/SgymtE5zBvLn+kMDy1LXW1isatlHlo1lj/TGV3CvVFsNGPUkv3Yl54vOhYREZFQ+9LzMXrpfhQbzYgP98EXT3dCAw23rK9tLHZ1oIFGhWVjOqNbRCOUmix4atl+7ErLEx2LiIhIiD1n8jFm2QGUmizoFtEIS8d0gpsLS11dYLGrI64uSix+Kha9WjZGeYUVz3xxANtP54qORUREVK92pubh6S/2o6zCgh4tGmPxU7FwdVGKjuWwWOzqkFatxIJRMbivtR+MZiueXZGIHaksd0RE5BwSTudi7PIDKK+woncrXywcFQOtmqWuLrHY1TGNSom5I6Kry9245Ym8LEtERA4v4XQunl2RCKPZivta+2HeyGiWunrAYlcPXFQKzB0RjT6tfGE0WzF2+QHsPsNyR0REjmlnah7+tiIRJrMV/dr4Ye6IaGhULHX1gcWunrioFJg7Mhr3/mnO3V7eLUtERA5m95k8jFtxoHqkbs6T0XBRsW7UF36m65FGpcS8kTHo2aKy3D297ACXQiEiIoexLz0fY79IrJ5T9/mIKJa6esbPdj3744aK7s0boazCgqe/OIAD57iIMRER2bfEcwV4+osD1Xe/8vKrGCx2AmjVSiwaHVu9zt2Ypfu5QwUREdmtQxlXrlqnjne/isNiJ8gf5a5rMx+UmCx4aukBHMq4IjoWERHRbTmSWYinlvxvR4lFo2NZ6gRisRPI1UWJJU91Qny4D4qNZjy1ZD+OZBaKjkVERFQjxy7oMWrJvuq9X5eM4eLDorHYCebqosSSMbGIC/NGkdGM0Uv341S2QXQsIiKimzpxUY+RS/bBUG5GbEhDLOM2YTaBxc4GuLmosGRMJ0Q19YK+rAKjluxDem6x6FhERETXdfpSEUYu3gd9WQWim3rhi2c6o4GGpc4WsNjZCHeNCl+M6Yw2AZ7IKzZhxOJ9yCwoFR2LiIjoKufzSzBy8T5cKa1A+yY6fPFMZ7iz1NkMFjsbonNT48uxnRHh645sfTlGLN6HS4Zy0bGIiIgAABcLy/Dkon24XGRESz8PLH+6Mzy1atGx6E9Y7GyMj7sGK8fGoam3GzIKSjFi8T7kFxtFxyIiIieXW2TEyMX7kFVYhrBGDfDluM5o2MBFdCz6CxY7G+Sv0+KrcXEI0GmRdrkYo5bsh76sQnQsIiJyUvrSqvnfeSUI8nLFynFx8PXQio5F18FiZ6OCvd2wclwcGrm74GS2AWOW7UeJ0Sw6FhEROZlioxlPLduP5JwiNHLXYOW4OAR5uYqORTfAYmfDmjV2x5dj46BzVSMpoxDjlieivMIiOhYRETmJ8goLxi0/gMOZhfByU+OrcXEIa9RAdCy6CRY7G9c6wBMrqu442pOejwkrD8JktoqORUREDs5ktmLCyoPYm14Ad40KK57pjJb+HqJj0S2w2NmBDsFeWPJULLRqBbam5OLF1UkwW1juiIiobpgtVry05jC2puRCq1Zg6ZhOaN/ES3QsqgEWOzsRF+6DBaNi4aJU4KfjOXj9u+OQZVl0LCIicjCyLGP6+mP48Vg2XJQKLBgVi85h3qJjUQ2x2NmRni0a49MnoqCQgDWJmZi1OUV0JCIicjDv/ZSMtQcvQKmQ8OkTUejZorHoSHQbWOzszIBIf7w7tB0A4POtZ7Bs11nBiYiIyFEsSDiDBdvTAQDvDWuHAZH+ghPR7WKxs0OPd26Kaf1aAADe+uEkvj+cJTgRERHZu7WJmZj5UzIAYPrAVngkNlhwIroTLHZ2atK9ERjTNRQAMG3tEWw/nSs2EBER2a1fT17Ca+uPAQD+1iMcz/VsJjgR3SkWOzslSRLeeKANHuwQiAqLjPErD+JwZqHoWEREZGcOnCvApFWHYLHKGB7dBK8NaCU6Et0FFjs7plBI+PCRDujevBFKTRY8vWw/zuQWi45FRER2IjnHgLFfHIDRbEWfVr54b3g7KBSS6Fh0F1js7JyLSoF5I2PQvokOV0orMHrJfuToy0XHIiIiG5dZUIrRS/bDUG5GbEhDzHkyGmola4G941fQAbhrVFg2phPCGzVAVmEZnlq6H/rSCtGxiIjIRuUVGzF66X5cLjKipZ8HljzVCa4uStGxqBaw2DkIH3cNlj/TGX6eGqRcKsLY5QdQZuK+skREdLWi8gqMWbYfZ/NKEOTlihVjO0PnphYdi2oJi50DCfZ2w/JnOsNTq0Li+SuYvOoQtx4jIqJqlfu/HsLxLAN8Grjgy7Gd4eepFR2LahGLnYNp5e+JJWM6QaNS4Lfky5i+/hi3HiMiIsiyjNfWHcXOtDy4uSix7OlOCG/sLjoW1TIWOwfUKdQbc56MhlIhYe3BC3j/Z249RkTk7D7cfBrrk7KgVEiYOyIa7Zt4iY5EdYDFzkH1beOHmVVbj81POIPlu8+JDURERMKs2peBOVvTAAAzh7ZDr5a+ghNRXWGxc2CPdgrG3/u3BAC89cMJ/HbqkuBERERU3347dQn/2FC5q8SLfZrj0U7cKsyRsdg5uIm9muGx2GBYZWDyqiQcu6AXHYmIiOrJkcxCTF6VBKsMPBLTBFPuay46EtUxFjsHJ0kS/j00Et2bN0JZhQXPLD+ArMIy0bGIiKiOZeSXVi59VWFBjxaN8e6wdpAk7irh6FjsnIBaqcDnI6LRyt8DuUVGPL1sPwzlXMCYiMhRFZSY8NSy/cgrNqFtoCfmjuCuEs6CX2Un4alVY+mYTvD10OD0pWJMXHkIFVzjjojI4ZRXWDBu+YHqBYiXjekEd41KdCyqJyx2TiTQyxVLx3SCm4sSO9Py8Pp3XOOO6tfMmTPRqVMneHh4wNfXF0OGDEFKys2X49m2bRskSbrmkZycXE+pieyH1Spj6jeHcSijEJ5aFZY/0wm+XIDYqbDYOZnIIB3mPBkFhQR8k3gBn1fd/k5UHxISEjBp0iTs3bsXW7ZsgdlsRr9+/VBSUnLL56akpCA7O7v60bw5J4ET/dWszSnYdCwHaqWERaNjEeHrIToS1TOOzTqh3q388NZDbfHP709g1ubTaNLQDUOigkTHIifw888/X/XysmXL4Ovri4MHD6JHjx43fa6vry+8vLzqMB2RffsmMRNzt50BALw3rD3iwn0EJyIROGLnpEbFh+JvPcIBAK98exT70vMFJyJnpNdXLr/j7e19y3OjoqIQEBCAPn36YOvWrTc912g0wmAwXPUgcmS7z+RhxvrKtepe6B2B4TFNBCciUVjsnNhrA1phYKQ/TBYr/vblQZzJLRYdiZyILMuYOnUqunXrhsjIyBueFxAQgIULF2LdunVYv349WrZsiT59+mD79u03fM7MmTOh0+mqH8HBXJCVHNeZ3GJMWHkIZquMBzsE4qW+LURHIoEkmbPnnVp5hQVPLNqLpIxCNPV2w/qJXdHIXSM6FjmBSZMm4ccff8TOnTvRpMntjS48+OCDkCQJGzduvO7rjUYjjEZj9csGgwHBwcHQ6/Xw9PS8q9xEtqSgxIShc3fhfH4popt6YdWzXaBVK0XHIoE4YufktGolFo2ORVNvN2QUlOLZFYkor7CIjkUO7vnnn8fGjRuxdevW2y51ANClSxekpqbe8PUajQaenp5XPYgcjdFswXNfJuJ8fimaNHTFwtGxLHXEYkdAI3cNlj3dCZ5aFZIyCjGDy6BQHZFlGZMnT8b69evx+++/Iyws7I7eTlJSEgICAmo5HZH9kGUZr607hgPnrsBDo8KyMZ14tYUA8K5YqtKssTvmjojBU8v2Y/2hLLT088BzPZuJjkUOZtKkSVi1ahW+//57eHh4ICcnBwCg0+ng6uoKAJg+fTqysrKwYsUKAMDs2bMRGhqKtm3bwmQyYeXKlVi3bh3WrVsn7OMgEu2z39PwXVIWlAoJc0dGo7kflzWhShyxo2rdmjfCGw+0AQC893Myfk++JDgROZp58+ZBr9ejV69eCAgIqH6sWbOm+pzs7GxkZGRUv2wymTBt2jS0b98e3bt3x86dO/Hjjz9i2LBhIj4EIuF+PJqNj7acBgD8e0gkujdvLDgR2RLePEFXkWUZr284jlX7MuCuUWH9xK5owf8Eyc4ZDAbodDrePEF273iWHg/P343yCivGdQvDP6r+GSf6A0fs6CqSJOGth9oiLswbxUYzxi1PxJUSk+hYREROL7fIiL+tSER5hRU9WzTG9EGtRUciG8RiR9dQKxWYNzIGwd6uyCgoxYSvDqLCYhUdi4jIaZnMVkxYeRAX9eUIb9QAnz4RBaVCEh2LbBCLHV2XdwMXLHmqExq4KLE3vQD/2nhCdCQiIqckyzL+ueE4Es9fgYdWhUVPxULnqhYdi2wUix3dUAs/D3zyeBQkCfhqXwa+3HNOdCQiIqezfPc5rEnMhEICPn0iCs0au4uORDaMxY5u6r42fnilfysAwL9+OIldaXmCExEROY9daXl458dTAIDpA1vj3pa+ghORrWOxo1sa3zMcQ6OCYLHKmPjVIZzLKxEdiYjI4Z3PL8HErw7BYpUxLDoI47rf2YLe5FxY7OiWJEnCzGHt0DHYC/qyCoxdfgCG8grRsYiIHFZReQXGLU+EvqwCHYO98O7QdpAk3ixBt8ZiRzWiVSuxcFQM/D21OJNbghe+ToLFyiUQiYhqm8UqY8rqw0i9XAw/Tw0WjorhHrBUYyx2VGO+nlosGh0LrVqBbSm5+Lhq5XMiIqo9H25OwW/Jl6FRKbBwVCx8PbWiI5EdYbGj29KuiQ7vD28PAJizNQ2bT+QITkRE5Dh+PJqNudvOAAD++3B7dAj2EhuI7A6LHd22wR2D8PQ9oQCAqd8cwZncYrGBiIgcQOqlIvz92yMAgOd6hGNwxyDBicgesdjRHZkxqDU6h1ZuOzb+y4MoMZpFRyIisluG8go89+VBlJosuCfCB3/v31J0JLJTLHZ0R9RKBeaMiIKvhwapl4vxyrdHIcu8mYKI6HZZrTJe/uYI0vNKEKjT4tPHo6BS8s8z3Rl+59Ad8/XQYt7IaKiVEn48lo1FO9JFRyIisjtzt6Vhy8lLcFEpMH9UDHzcNaIjkR1jsaO7EhPijTceaAMAeO+nZOzmzhRERDW2LeUyPqxaYeDfgyPRvomX2EBk91js6K6N7BKCYdFBsMrA5K+TcLGwTHQkIiKbl1lQihdXH4YsA0/GNcWjnYJFRyIHwGJHd02SJLw7tB3aBHiioMSECSsPorzCIjoWEZHNKjNZ8NyXB6t3lnjzwTaiI5GDYLGjWqFVK7FgVAx0rmocuaDHWz+cEB2JiMgmybKM1787hpPZBvg0cMG8kdHQqLizBNUOFjuqNcHebvj0iShIEvD1/kys3p8hOhIRkc1Zsec81idlQamQMOfJaAToXEVHIgfCYke1qmeLxni5bwsAwBvfn8DhzEKxgYiIbEhSxhX8+8eTAIDpA1shvpmP4ETkaFjsqNZN7BWBvm38YLJYMWHlQeQXG0VHIiISrrDUhMmrklBhkTGonT/GdgsTHYkcEIsd1TqFQsKHj3ZAeKMGyNaX46VvjsBq5eLFROS8/liEOKuwDKE+bnhveHtIkiQ6FjkgFjuqE55aNeaOjIZGpcD207mYv/2M6EhERMIs3JGO35Ivw0WlwOcjouGpVYuORA6KxY7qTCt/T7z1UFsAwIebT+PAuQLBiYiI6t/+swX44JcUAMBbD7VF20Cd4ETkyFjsqE491ikYgzsGwmKV8cLXSbhSYhIdiYio3uQVG/H814dgscoYGhWEx7kIMdUxFjuqU5Ik4T9D21XPt3t5LefbEZFzsFhlTFl9GJcMRkT4uuPfQyI5r47qHIsd1Tl3jQpznoyGi0qB35MvY/HOdNGRiIjq3Jzf07AzLQ+uaiXmjYhGA41KdCRyAix2VC/aBHrijQcqt8z5788pOJRxRXAiIqK6systD7N/Ow0A+M/QSDT38xCciJwFix3VmxFxTfFA+wCYrTKeX5WEwlLOtyMix3PJUI4XVydBloHHOwVjWHQT0ZHIibDYUb2RJAkzh7VDqI8bsgrLMG3tUcgy59sRkeMwW6x4/usk5BWb0MrfA/+qWhmAqL6w2FG98tCqK+fbKRX49dQlLNl5VnQkIqJa88lvqdh/tgDuGhXmjoiGVq0UHYmcDIsd1bvIIB3+8UBrAMD7PydzP1kicgh7zuRjztY0AMDMYe0Q3thdcCJyRix2JMSoLiEY1M4fFRYZk1cdgr6sQnQkIqI7VlBiwpQ1lfPqHosNxoMdAkVHIifFYkdCSJKE94a3R7C3Ky5cKcMr3x7hfDsiskuyLOOVb4/iksGI8MYN8OZDbURHIifGYkfCeGrV+PzJaKiVEn45cQnLd58THYmI6LZ9ufc8fj11CS5KBT57IgpuLlyvjsRhsSOh2jfxwoxBlfPt3t2UjGMX9IITERHVXHKOAf/+8RQAYPqgVtwHloRjsSPhxnQNRf+2fjBZrJj89SEUG82iIxER3VKZyYLnVyXBZLaidytfjOkaKjoSEYsdiSdJEv47vAOCvFxxPr8Ub208IToSEdEtvfPjSaReLoavhwYfPNye+8CSTWCxI5ugc1Pjo0c7QJKAtQcv4Kdj2aIjERHd0E/HsrFqXwYkCfj4sY7wcdeIjkQEgMWObEhcuA8m9GwGAHht/THk6MsFJyIiulZWYRleXXcUADC+ZzPcE9FIcCKi/2GxI5sy5b4WaBekg76sAi+vPQyrlUugEJHtMFusmLI6CYZyMzoEe2Fq3xaiIxFdhcWObIqLSoHZj3eEq1qJXWn5WLqLW44Rke2YszUNB85dgbtGhc8ej4JayT+jZFv4HUk2p1lj9+otx/77cwpOXjQITkREBBw8X4BPf0sFAPxnaCSa+rgJTkR0LRY7sklPdm6K+1pXLoEyZU0SyissoiMRkRMrMZrx0pojsMrAsKggDO4YJDoS0XWx2JFNkiQJ7w9vh0buGpy+VIz3fkoWHYmInNg7/3cSGQWlCPJyxb8GtxUdh+iGWOzIZvm4a/DBI+0BAF/sPoeE07mCExGRM9py8hJWH8iEJAEfPtoBnlq16EhEN8RiRzbt3pa+eCo+BAAwbe0R5BcbBSciImeSW2TEa1VLm/ytezi6hPsITkR0cyx2ZPOmD2qN5r7ulb9g1x+DLHMJFCKqe7IsY/r6o8gvMaGVvwem9uPSJmT7WOzI5mnVSsx+vCPUSqn6kgjZp5kzZ6JTp07w8PCAr68vhgwZgpSUlFs+LyEhATExMdBqtQgPD8f8+fPrIS05uzUHMvHrqctwUVYuw6RRKUVHIrolFjuyC20DdZjWryUA4O0fTiI9t1hwIroTCQkJmDRpEvbu3YstW7bAbDajX79+KCkpueFzzp49i0GDBqF79+5ISkrCjBkz8MILL2DdunX1mJyczbm8Erz9fycBAH/v3xKt/D0FJyKqGUnmdS2yE1arjBGL92FPej46NNHh2wlduTioncvNzYWvry8SEhLQo0eP657z6quvYuPGjTh16lT1sfHjx+PIkSPYs2dPjd6PwWCATqeDXq+Hpyf/QNPNmS1WPLpgDw5lFKJLuDdWjesChUISHYuoRvhXkeyGQiFV3ZGmwpELeszfdkZ0JLpLer0eAODt7X3Dc/bs2YN+/fpddax///5ITExERUXFdZ9jNBphMBiuehDV1LxtZ3AooxAeGhU+fLQjSx3ZFRY7siuBXq54e3AkAODT31O5K4Udk2UZU6dORbdu3RAZGXnD83JycuDn53fVMT8/P5jNZuTl5V33OTNnzoROp6t+BAcH12p2clzHLujxSdXuEm8PaYsgL1fBiYhuD4sd2Z3BHQPRr40fKiwyXl57BCazVXQkugOTJ0/G0aNH8fXXX9/yXEm6esTkjxkkfz3+h+nTp0Ov11c/MjN5ww3dmtFswctrD8NslXF/uwAM4e4SZIdY7MjuSJKE/wxth4ZuapzKNmDO76miI9Ftev7557Fx40Zs3boVTZo0uem5/v7+yMnJuerY5cuXoVKp4ONz/TXFNBoNPD09r3oQ3cqnv6Xi9KViNHJ3wTtDIm/4jwORLWOxI7vU2EODd4ZUXr77fNsZHLugF5yIakKWZUyePBnr16/H77//jrCwsFs+Jz4+Hlu2bLnq2ObNmxEbGwu1mjsAUO04klmI+QnpAIB/D4mEdwMXwYmI7gyLHdmtB9oH4v72AbBYZby89jCMZovoSHQLkyZNwsqVK7Fq1Sp4eHggJycHOTk5KCsrqz5n+vTpGD16dPXL48ePx/nz5zF16lScOnUKS5cuxZIlSzBt2jQRHwI5oPIKC6atPQKLVcaDHQIxIDJAdCSiO8ZiR3btncGRaOTugtOXijH7V16StXXz5s2DXq9Hr169EBAQUP1Ys2ZN9TnZ2dnIyMiofjksLAybNm3Ctm3b0LFjR7zzzjv49NNPMXz4cBEfAjmgT35LRerlYjRy1+Dth9qKjkN0V7iOHdm9n4/nYPzKg1BIwLcTuiK6aUPRkcjGcB07upHDmYUYNncXrDKwYFQM+rf1Fx2J6K5wxI7s3oBIfwzpGAirDExbewTlFbwkS0S39sclWKtcebc9Sx05AhY7cgj/eqgtfD00SM8twaxfbr33KBHR7F9TkVZ1CfZfD/ISLDkGFjtyCF5uLnhveDsAwJJdZ3HgXIHgRERky5IyrmDh9srda94dGomGvAuWHASLHTmM3q388EhME8hVl2RLTWbRkYjIBv35EuyQjoHox0uw5EBY7Mih/PPBNgjQaXE+vxQfbT4tOg4R2aCPt5zGmdwSNPbQ4F+8C5YcDIsdORRPrRrvDq28JLt011kcySwUG4iIbMqhjCtYtKNyIeKZQ9vBy42XYMmxsNiRw7m3lS8GV90l++q6o6iwcC9ZIrr6EuywqCDc18ZPdCSiWsdiRw7pjQfaoKGbGsk5RVi4PV10HCKyAXN+T0N61SXYN3kXLDkoFjtySD7uGrzxYBsAlavKn8ktFpyIiERKzjFgfkLlXbDvDG4LnRv3GSbHxGJHDmtIxyD0bNEYJrMV09cdg9XKTVaInJHFKuPVdcdgtsro18aPe8GSQ2OxI4clSRL+MzQSbi5K7D9XgFX7M279JCJyOCv2nMORzEJ4aFR4e3Ck6DhEdYrFjhxak4Zu+Hv/lgCA935KRo6+XHAiIqpPF66U4oOq3WheHdgK/jqt4EREdYvFjhze6PhQdAz2QrHRjH9sOA5Z5iVZImcgyzL+ueE4Sk0WdAptiCc7NxUdiajOsdiRw1MqJPz34fZQKyX8euoSNh3LER2JiOrBD0ezsTUlFy5KBWYOaw+FQhIdiajOsdiRU2jh54EJvSIAAG9uPI7CUpPgRERUl66UmPDWxhMAgEn3RiDC111wIqL6wWJHTmPSvc0Q4euOvGIT/v3jKdFxiKgO/WfTKeSXmNDCzx0TejUTHYeo3rDYkdPQqJR4f3h7SBLw7cEL2JmaJzoSEdWBnal5+PbgBUgSMHNYe7io+KeOnAe/28mpxIQ0xOguIQCA6d8dRanJLDgREdWmMpMFM747BgAY3SUEMSENBSciql8sduR0/j6gFQJ1WmQWlOGjzadFxyGiWjT719PIKChFgE6Lvw9oJToOUb1jsSOn465R4T9D2wEAlu46ixMX9YITEVFtOJ6lx+KdZwEA7wyOhLtGJTgRUf1jsSOndG8rXzzQPgBWGfjHhuPcbozIzlmsMqavPwaLVcb97QNwXxs/0ZGIhGCxI6f1zwfawF2jQlJGIb5JzBQdh4juwqp953EsSw8PrQpvPthGdBwiYVjsyGn5eWrxUt8WAID3fk5GQQnXtiOyR7lFRvy3atuwv/dvCV8PbhtGzovFjpzaU/EhaOXvgcLSCrz3E9e2I7JHMzedQlG5GZFBnhgRFyI6DpFQLHbk1FRKBf4zNBIA8E3iBSSeKxCciIhux970fKxPyoIkAf8e0g5KbhtGTo7FjpxeTIg3HosNBlB5I4XZYhWciIhqwmS24p8bjgMAnuzcFB2DvcQGIrIBLHZEAF4d2Apebmok5xThi93nRMchohpYuussUi8Xw6eBC17pzzXriAAWOyIAgHcDF7xWtZjpx1tOI0dfLjiR7amoqEBmZiZSUlJQUMBL1iRWVmEZPvk1FQAwfVBr6NzUghMR2QYWO6Iqj8YGI7qpF0pMFrzz40nRcWxCcXExFixYgF69ekGn0yE0NBRt2rRB48aNERISgmeffRYHDhwQHZOc0Ns/nEBZhQWdQ70xPDpIdBwim8FiR1RFoZDw7yHtoJCAH49mY/vpXNGRhPr4448RGhqKRYsWoXfv3li/fj0OHz6MlJQU7NmzB2+++SbMZjP69u2LAQMGIDU1VXRkchK/J1/CLycuQamQ8M6QSEgSb5gg+oMkyzKX3Cf6k7d/OImlu84i1McNP0/pAa1aKTqSEI888gjeeOMNtGvX7qbnGY1GLFmyBC4uLhg3blw9pbs9BoMBOp0Oer0enp6eouPQXSivsKDvxwnILCjD33qEY8ag1qIjEdkUFjuivygqr0CfDxNwuciIqX1b4IU+zUVHEq6oqAgeHh6iY9wxFjvH8dHmFHz6exr8PbX47eWeaMD9YImuwkuxRH/hoVXjnw9Ubkk0Z2sazueXCE4kXvfu3ZGTkyM6Bjm59NxizE9IBwC8+WAbljqi62CxI7qOB9oHoFtEI5jMVry58QScfWA7NjYWcXFxSE5Ovup4UlISBg0aJCgVORNZlvHG9ydgsljRs0VjDIj0Fx2JyCax2BFdhyRJeHtwW7goFdiWkotfTjj3aNXixYvxzDPPoFu3bti5cydOnz6NRx99FLGxsdBoNKLjkRPYdCwHO9Py4KJS4K2H2vKGCaIb4Dg20Q2EN3bHcz3D8dnvaXj7h5Po2cIXri7OeSMFALz55ptwcXFB3759YbFY0L9/fxw4cADR0dGio5GDKzNZ8O6myr2cJ/RshtBGDQQnIrJdHLEjuolJ90YgyMsVF/XlmJ9wRnQcYbKzs/HCCy/gnXfeQZs2baBWq/H444+z1FG9WLD9DLIKyxDk5YrxPZuJjkNk01jsiG5Cq1ZWL6cwP6Hyj4szCg8Px44dO7B27VocPHgQ69evx8SJE/H++++LjkYOLquwrPqfqumDWjn1qDlRTbDYEd3CoHb+iAvzhtFsrb4c5GyWLVuGpKQk3H///QCA/v37Y+vWrfjkk08wceJEwenIkc3cdArlFVbEhXnj/nYBouMQ2TwWO6JbkCQJbz7YtnpHin3p+aIj1bvHH3/8mmPR0dHYvXs3tm3bVv+ByCnsS8/H/x3NhkIC3niwDW+YIKoBFjuiGmgT6IknOjcFAPzrh5OwWJ17+ZM/hIaGYteuXaJjkAOyWGW89UPlns2Pd26KtoE6wYmI7AOLHVENvdyvJTy1KpzKNmDNgUzRcepcRkZGjc5r2LAhACArK6su45CTWXMgEyezDfDUqvBy3xai4xDZDRY7ohrybuCCl6r+wMzanAJ9aYXgRHWrU6dOePbZZ7F///4bnqPX67Fo0SJERkZi/fr19ZiOHJm+rAKzNqcAAKbc1wI+7lwrkaimuI4d0W0Y2SUEq/ZlIPVyMT75LRVvPNhGdKQ6M3jwYHh4eGDAgAFQq9WIjY1FYGAgtFotrly5gpMnT+LEiROIjY3FBx98gIEDB4qOTA7ik19TUVBiQoSvO0bFh4iOQ2RXJNnZ90oiuk07UnMxasl+qBQSfp7SHRG+HqIj1QkXFxdkZmbC09MTfn5+ePTRR5Gfn4+ysjI0atQIUVFR6N+/PyIjI0VHvSWDwQCdTge9Xg9PT0/Rcegm0i4XYcDsHTBbZax4pjN6tGgsOhKRXeGIHdFt6t68Me5r7YdfT13CWz+cxIpnOjvk3XpBQUFISkrCgAEDUFxcjHfffRe+vr6iY5EDk+XKGybMVhn3tfZjqSO6A5xjR3QH/vlAa7goFdiRmoffTl0WHadOTJs2DQ899BC6du0KSZLw1Vdf4cCBAygrc85Fmqnu/XbqMnak5sFFqcA/7m8tOg6RXWKxI7oDIT4NMLZ7GADgnR9Pwmi2CE5U+yZNmoSkpCQ88MADkGUZn3/+OeLj4+Hp6YnWrVvj8ccfx3vvvYeffvpJdFRyAEazBf/+sXJ5k2e6hXE/WKI7xDl2RHeo2GhG71nbcLnIiNcGtnLoPSwjIiKwd+9eNGjQAEePHsXhw4erH8ePH0dRUZHoiDfFOXa2b37CGbz3UzIae2iwdVovuGs4U4joTnDEjugOuWtUeHVAKwDAZ7+l4rKhXHCiupOWloZGjRrB1dUVcXFxeO655zBv3jzs2bMHBoPhtt7W9u3b8eCDDyIwMBCSJGHDhg03PX/btm2QJOmaR3Jy8l18RGRLLheV47PfUgEArw5oxVJHdBdY7IjuwtCoIHQI9kKJyVK97pazud0bR0pKStChQwfMmTPntp6XkpKC7Ozs6kfz5s1v6/lku2b9koISkwUdgr0wLCpIdBwiu8Z/i4jugkIh4Y0H2mD4vN1Ye/ACnukWhlb+vNR3MwMHDryjNe98fX3h5eVVo3ONRiOMRmP1y7c7qkj151S2AWsPXgAAvPFAGygUjneHOVF94ogd0V2KCWmI+9sFQJaBmZt4ebCuREVFISAgAH369MHWrVtveu7MmTOh0+mqH8HBwfWUkm7XzJ+SIcvA/e0DEBPSUHQcIrvHYkdUC14Z0BJqpYSE07nYfjpXdByHEhAQgIULF2LdunVYv349WrZsiT59+mD79u03fM706dOh1+urH5mZjr+3rz364+dFrZTwav9WouMQOQReiiWqBSE+DTCqSyiW7jqLdzedwj0RjaDkJaVa0bJlS7Rs2bL65fj4eGRmZmLWrFno0aPHdZ+j0Wig0XB/UVtmscqYuekUAGB0fCia+rgJTkTkGDhiR1RLnu8dAU+tCsk5RVh/6ILoOA6tS5cuSE1NFR2D7sK6QxeQnFMET60Kz/eOEB2HyGGw2BHVkoYNXDC56g/UrM0pKDM53qLFtiIpKQkBAQGiY9AdKjWZ8WHVXeTP924OLzcXwYmIHAcvxRLVotHxoVix5zwuXCnD4h3peL4Pl+T4q+LiYqSlpVW/fPbsWRw+fBje3t5o2rQppk+fjqysLKxYsQIAMHv2bISGhqJt27YwmUxYuXIl1q1bh3Xr1on6EOguLdlxFpcMRjRp6IrRXUNExyFyKByxI6pFWrUSr1QtWjw/4Qxyi4y3eIbzSUxMRFRUFKKiogAAU6dORVRUFN544w0AQHZ2NjIyMqrPN5lMmDZtGtq3b4/u3btj586d+PHHHzFs2DAh+enu5BYZMT/hDADglQGtoFEpBScicizcUoyolsmyjCGf78KRC3qMiGuK/wxtJzqS0+OWYrbj9e+O4at9GegQ7IUNE7ve9gLXRHRzHLEjqmWSJGHGoNYAgNUHMpF22bb3USWqL6mXirD6QOXSM68Pas1SR1QHWOyI6kBcuA/6tfGDxSrjvZ+4aDERALz3UzIsVhn92vihc5i36DhEDonFjqiOvDqwFZQKCb+euow9Z/JFxyESaveZPPyWfBlKhYRXB3IxYqK6wmJHVEeaNXbHiLimAIB3N52C1crprOScrFYZ71YtRjwirimaNXYXnIjIcbHYEdWhF/s0h7tGhWNZemw8clF0HCIhNh65iONZBrhrVHiRSwAR1SkWO6I65OOuwYRezQAAH/ySgvIKLlpMzqW8woIPfqlcjHhCr2bwcedWb0R1icWOqI6N7RaGAJ0WWYVlWL77nOg4RPXqi93nkFVYhgCdFmO7hYmOQ+TwWOyI6phWrcTL/So3sZ+XcAaG8grBiYjqh760AnO3Vu4y8nK/ltCquRgxUV1jsSOqB0OjgtDc1x2FpRVYtD1ddByierFg+xkYys1o4eeOoVFBouMQOQUWO6J6oFRI1aN2S3ae5VZj5PAuG8qxbNc5AMC0fi2hVHAxYqL6wGJHVE/6t/VDh2AvlJos+Lzq8hSRo/rs9zSUVVgQ1dQLfdv4iY5D5DRY7IjqiSRJeLV/5ajdV/vOI7OgVHAiorqRkV+Kr/dnAABeHdCKW4cR1SMWO6J61DWiEbpFNEKFRcbsX1NFxyGqEx9tSYHZKqNHi8boEu4jOg6RU2GxI6pnf68atVufdAGnLxUJTkNUu05lG/B91WLcr1R9rxNR/WGxI6pnHYK9MDDSH7IMzKpauJXIUcz6JQWyDDzQPgCRQTrRcYicDosdkQAv92sBhQRsPnkJSRlXRMchqhUHzhXgt+TLV90FTkT1i8WOSIAIXw8Mj24CAPjvzymQZVlwIqK7I8sy/vtzMgDg0dhghDVqIDgRkXNisSMSZErfFnBRKrAnPR870/JExyG6K9tScnHg3BVoVAq82Ke56DhETovFjkiQIC9XjOwSAgD44BeO2pH9slplvF81Wjemayj8dVrBiYicF4sdkUCT7m2GBi5KHL2gx8/Hc0THIbojPxy9iOScInhoVZjQq5noOEROjcWOSCAfdw3Gdg8HAHywOQVmi1VwIqLbU2Gx4qMtpwEA43s2g5ebi+BERM6NxY5IsGe7h6GhmxrpuSVYfyhLdByi2/LtwQs4n1+KRu4aPH1PqOg4RE6PxY5IMA+tGpPujQAAzP71NMorLIITEdWM0WzBZ79V7qAysVczuLmoBCciIhY7IhswsksIAnRaXNSXY9W+DNFxiGrkmwOZuKgvh5+nBk/GNRUdh4jAYkdkE7RqJZ7vXblExLyEMygzcdSObFt5hQVztqYBACbfGwGtWik4EREBLHZENuOR2CYI9nZFbpERK/eeFx2H6Ka+3p+BSwYjAnVaPNopWHQcIqrCYkdkI9RKRfWo3fyEMygxmgUnIrq+MpMFc7edAQBM7t0cGhVH64hsBYsdkQ0ZFhWEEB835JeYsGIPR+3INq3cex65RUY0aeiKh2OaiI5DRH/CYkdkQ1TK/23HtGD7GRSVVwhORHS1EqMZ8xMqR+te6N0cLir+GSGyJfyJJLIxD3UIRHjjBigsrcDy3edExyG6yoo955FfYkKIjxuGRQeJjkNEf8FiR2Rj/jxqt3B7OvRlHLUj21BUXoEF2ytH617s0xwqJf+EENka/lQS2aAH2geihZ87DOVmLN15VnQcIgDA8t3nUFhagfDGDfBQh0DRcYjoOljsiGyQUiFhyn0tAABLd55FYalJcCJydobyCizcng6Ao3VEtow/mUQ2akBbf7Ty90CR0YzFOzhqR2It2XEWhnIzmvu644H2HK0jslUsdkQ2SqGQ8FLfylG7ZbvOoqCEo3YkRmGpqXpKwEt9W0CpkAQnIqIbYbEjsmH92vihbaAnSkyW6knrRPVt8Y6zKDKa0crfAwPa+ouOQ0Q3wWJHZMMkScLUqlG7FbvPI6/YKDgROZuCEhOW7frfaJ2Co3VENo3FjsjG9W7liw5NdCirsGDRjnTRccjJLNyejhKTBW0DPdGvjZ/oOER0Cyx2RDZOkiS8ULWu3Zd7znOuHdWbvGJj9SLZU/u2gCRxtI7I1rHYEdmB3q18ERnkiVKTBYs5akf1ZOH2dJRVWNChiQ69W/mKjkNENcBiR2QHJEnCC70rR+0qF4nlqB3VrfxiI77ccx4AMOU+jtYR2QsWOyI70beNH1oHVN4hy90oqK4t2XkWZRUWtAvSoVfLxqLjEFENsdgR2YnKUbsIAMCyXee4hyzVmcJSU/Xcuud7R3C0jsiOsNgR2ZH+bf3R0q9yN4ovdp0THYcc1NJd51BisqB1gCf68k5YIrvCYkdkRxQKCc/3qRy1W7IzHUXlHLWj2qUvq6het+4FjtYR2R0WOyI7MzAyABG+7jCUm6svlxHVluW7z6Go3IwWfu7oz10miOwOix2RnVEqJDxfNddu8c6zKDaaBSciR1FUXoElVTfmTO7dnLtMENkhFjsiO/RA+0CEN2qAwtKK6iUpiO7Wl3vPQ19WgfDGDXB/uwDRcYjoDrDYEdkhpULC5KpRu0U70lFqsp9Ru+3bt+PBBx9EYGAgJEnChg0bbvmchIQExMTEQKvVIjw8HPPnz6/7oE6mxGjG4h2Vo3XP946AkqN1RHaJxY7ITj3UIRAhPm4oKDHhq70ZouPUWElJCTp06IA5c+bU6PyzZ89i0KBB6N69O5KSkjBjxgy88MILWLduXR0ndS5f7avcri7Exw0Ptg8UHYeI7pBKdAAiujMqpQKT7o3AK98exYLt6RjZJQSuLkrRsW5p4MCBGDhwYI3Pnz9/Ppo2bYrZs2cDAFq3bo3ExETMmjULw4cPr6OUzqXMZMHC7ZVb1U26NwIqJf/nJ7JX/OklsmNDo4IQ7O2KvGIjvt5vP6N2t2PPnj3o16/fVcf69++PxMREVFRcf7kXo9EIg8Fw1YNu7Ov9GcgrNqFJQ1cMjQoSHYeI7gKLHZEdUysVmNSrcq7d/IQzKK+wCE5U+3JycuDnd/UiuX5+fjCbzcjLy7vuc2bOnAmdTlf9CA4Oro+odqm8woL5CWcAABN7RUDN0Toiu8afYCI7Nyy6CQJ1WlwuMuLbgxdEx6kTf10kV5bl6x7/w/Tp06HX66sfmZmZdZ7RXn2TmInLRUYE6rQYHsPROiJ7x2JHZOdcVAr8rUc4gMpRuwqLVXCi2uXv74+cnJyrjl2+fBkqlQo+Pj7XfY5Go4Gnp+dVD7pWhcWKBQmVc+vG92oGjcr252gS0c2x2BE5gMc7N0UjdxdcuFKGH45cFB2nVsXHx2PLli1XHdu8eTNiY2OhVqsFpXIMG5KykFVYhkbuGjway8vVRI6AxY7IAWjVSjzTLQwAMHfbGVitsuBEN1ZcXIzDhw/j8OHDACqXMzl8+DAyMipv/pg+fTpGjx5dff748eNx/vx5TJ06FadOncLSpUuxZMkSTJs2TUR8h2Gxypi3rXJu3bPdw6BVc7SOyBGw2BE5iFFdQuCpVSHtcjF+OZFz6ycIkpiYiKioKERFRQEApk6diqioKLzxxhsAgOzs7OqSBwBhYWHYtGkTtm3bho4dO+Kdd97Bp59+yqVO7tJPx7ORnlcCnasaI7qEiI5DRLVEkv+YhUxEdu+jzSn49Pc0RAZ54ofJ3W54c4GzMRgM0Ol00Ov1nG+HyptPBn26E6eyDXixT3O81LeF6EhEVEs4YkfkQMbcEwZXtRLHswxIOJ0rOg7ZqK0pl3Eq2wA3FyWevidUdBwiqkUsdkQOxLuBC0bENQUAfL41TXAaskWyLGPO75XfGyO7hMDLzUVwIiKqTSx2RA7m2R7hcFEqcODcFew/WyA6DtmYvekFOJRRCBeVAuOqbrghIsfBYkfkYPw8tXg4tgkAYA5H7egv5m6r/J54LDYYvp5awWmIqLax2BE5oAk9m0GpkLD9dC6OXigUHYdsxJHMQuxIzYNSIVUvak1EjoXFjsgBBXu7YXCHQACca0f/88f3wpCOQQj2dhOchojqAosdkYOa0KsZAOCXE5eQeqlIcBoSLSWnCJtPXoIk/e97g4gcD4sdkYNq7ueBAW39AVTuRkHObV7V3LqBkf6I8HUXnIaI6gqLHZEDm3RvBABg45GLyMgvFZyGRDmfX4KNVXsIT+wVITgNEdUlFjsiB9auiQ49WjSGxSpj/naO2jmr+QlnYJWBXi0bIzJIJzoOEdUhFjsiBze5atTu28QLyNGXC05D9S1HX451B7MA/O97gYgcF4sdkYPrHOaNTqENYbJYsXhHuug4VM+W7EyHyWJF51BvxIZ6i45DRHWMxY7ICUysGqlZtT8DhaUmwWmovhSWmvDVvgwAwIR7eScskTNgsSNyAr1aNEbrAE+UmixYsee86DhUT5bvPo9SkwVtAjzRq0Vj0XGIqB6w2BE5AUmSqtcuW7brLEpNZsGJqK6Vmsz4YvdZAJXr1kmSJDgREdUHFjsiJzEo0h9Nvd1wpbQCaw5kio5DdWz1/kxcKa1AiI8bBkb6i45DRPWExY7ISaiUCjzXs3J/0EXb02EyWwUnorpiMluxqOpGmed6NINKyV/1RM6CP+1ETmR4dBM09tDgor68esFacjwbDmchW18OXw8NhscEiY5DRPWIxY7IiWjVSoztFgagatFaqyw4EdU2i1XG/ITKxajHdguDRqUUnIiI6hOLHZGTGRHXFB5aFdIuF2PLqUui41At23IyB+m5JfDUqjCiS4joOERUz1jsiJyMh1aNUVV/8OduOwNZ5qido5BlGXO3VY7WPdU1FO4aleBERFTfWOyInNDT94RBo1LgSGYh9qTni45DtWRXWj6OXtBDq1ZgTNdQ0XGISAAWOyIn1NhDg0djgwEA86pGeMj+zd2WBgB4vFNT+LhrBKchIhFY7Iic1N96hEOpkLAjNQ/HLuhFx6G7dDizELvP5EOlkDCue5joOEQkCIsdkZMK9nbDg+0DAKD6LkqyX/OqRuse6hiIJg3dBKchIlFY7Iic2PiqbcY2Hc9Gem6x4DR0p9IuF+GXE5V3OE/o2UxwGiISicWOyIm18vdEn1a+kGVg4fZ00XHoDi1IqPza9W3jh+Z+HoLTEJFILHZETm7ivZUjPOsOXUCOvlxwGrpdFwvLsOFwFgBgQi+O1hE5OxY7IicXE+KNzqHeqLDIWLKTo3b2ZsnOs6iwyOgS7o3opg1FxyEiwVjsiAgTqkbtVu3LQGGpSXAaqqkrJSZ8vT8DADChV4TgNERkC1jsiAi9WjRG6wBPlJgsWLHnvOg4VEMr9pxHqcmCNgGe6NG8keg4RGQDWOyICJIkVc/PWrbrLEpNZsGJ6FZKTWZ8sfssgMq5dZIkCU5ERLaAxY6IAACDIv3R1NsNV0orsHp/pug4dAur92fiSmkFQnzcMDDSX3QcIrIRLHZEBABQKRUYX7UG2qId6TCZrYIT0Y2YzFYs3lF5o8tzPZpBpeSvciKqxN8GRFRteEwQfD00yNaXY0NSlug4dAMbj1zERX05GntoMCw6SHQcIrIhLHZEVE2jUlbvMzo/4QwsVllwIvorq1Wu3gJubLcwaNVKwYmIyJaw2BHRVZ6MC4HOVY30vBL8ciJHdBz6i80nLyHtcjE8tCo8GddUdBwisjEsdkR0FXeNCk91DQUAzN2WBlnmqJ2tkGUZ87alAQBGx4fAU6sWnIiIbA2LHRFd4+muoXBVK3E8y4DtqXmi41CV3WfyceSCHlq1Ak/fEyY6DhHZIBY7IrpGwwYueKJz5WW+uVvTBKehP3xe9bV4vFNTNHLXCE5DRLaIxY6IruvZHmFQKyXsO1uAg+eviI7j9JIyrmD3mXyoFBKe7REuOg4R2SgWOyK6rgCdK4ZFNQGA6nldJM7cbZV3wg6JCkKQl6vgNERkq1jsiOiGnusZDkkCfj11Gck5BtFxnNbpS0XYcvISJAnVi0gTEV0Pix0R3VB4Y3cMigwAAMyrGjGi+je/6nM/oK0/InzdBachIlvGYkdENzWhV+UI0Q9HLiIjv1RwGueTWVCK749cBABM7BUhOA0R2ToWOyK6qcggHXq2aAyrDCzYzlG7+rZwezosVhndmzdCuyY60XGIyMax2BHRLU2sGrVbm3gBlw3lgtM4j8tF5ViTmAmAo3VEVDMsdkR0S53DvBET0hAmixVLdp4VHcdpLN15DiazFVFNvdAl3Ft0HCKyAyx2RHRLkiRVj9qt3Hse+tKKu3p7c+fORVhYGLRaLWJiYrBjx44bnrtt2zZIknTNIzk5+a4y2Dp9WQVW7j0PoHK0TpIkwYmIyB6w2BFRjfRu5YtW/h4oMVmwYs+5O347a9aswZQpU/D6668jKSkJ3bt3x8CBA5GRkXHT56WkpCA7O7v60bx58zvOYA9W7j2PYqMZLf080KeVr+g4RGQnWOyIqEYkSaq+Q3bprrMoNZnv6O189NFHGDt2LMaNG4fWrVtj9uzZCA4Oxrx58276PF9fX/j7+1c/lErlHb1/e1BmslRf8p7QqxkUCo7WEVHNsNgRUY3d3y4ATb3dcKW0Aqv3Z972800mEw4ePIh+/fpddbxfv37YvXv3TZ8bFRWFgIAA9OnTB1u3br3puUajEQaD4aqHPVl9IAMFJSYEe7vigfYBouMQkR1hsSOiGlMpFXiuZ+U+pQu3p8NottzW8/Py8mCxWODn53fVcT8/P+Tk5Fz3OQEBAVi4cCHWrVuH9evXo2XLlujTpw+2b99+w/czc+ZM6HS66kdwcPBt5RSpvMKC+QmVy8qM79kMKiV/TRNRzalEByAi+zI8ugk++y0NOYZyfJN4AaO6hNz22/jrjQCyLN/w5oCWLVuiZcuW1S/Hx8cjMzMTs2bNQo8ePa77nOnTp2Pq1KnVLxsMBrspd98kZuKSwYhAnRYPxzQRHYeI7Az/FSSi26JVK6vn2s3bmnZbo3aNGjWCUqm8ZnTu8uXL14zi3UyXLl2Qmpp6w9drNBp4enpe9bAHRrOleuu2Cb2aQaNy3HmERFQ3WOyI6LY91ikYfp4aXNSX49uDF2r8PBcXF8TExGDLli1XHd+yZQu6du1a47eTlJSEgADHm3v27cELyNaXw89Tg0di7WOEkYhsCy/FEtFt06qVGN+zGd764STmbj2DR2KC4aKq2f+JU6dOxahRoxAbG4v4+HgsXLgQGRkZGD9+PIDKy6hZWVlYsWIFAGD27NkIDQ1F27ZtYTKZsHLlSqxbtw7r1q2rs49PBJPZirlb/ze3TqvmaB0R3T4WOyK6I090boq5284gq7AM6w5dwBOdm9boeY899hjy8/Px9ttvIzs7G5GRkdi0aRNCQirn6mVnZ1+1pp3JZMK0adOQlZUFV1dXtG3bFj/++CMGDRpUJx+XKN8lXUBWYRkae2hq/LkkIvorSZZlWXQIIrJPS3aexTv/dxJBXq7YOq1XjUft6pvBYIBOp4Ner7fJ+XYVFit6f7gNmQVl+Mf9rTGue7joSERkp2zztzAR2YURcU3RyF2DrMIyrD9U87l2dLUNSVnILChDI3cXjIi7/buMiYj+wGJHRHescq5d5ejSnK1pqLBYBSeyP2aLFZ9vTQMAPNs9HK4unFtHRHeOxY6I7sqIuBA0ctfgwpUyfHcoS3Qcu/PD0Ys4l1+Khm5qjLyDNQGJiP6MxY6I7oqrixLP9eCo3Z2wWGV89nvlaN247uFooOH9bER0d1jsiOiujejSFD4NXJBRUIoNSRy1q6kfj2UjPbcEOlc1RsdztI6I7h6LHRHdNTcXFf72p1E7M0ftbslqlfHZb5W7Z4ztFgYPrVpwIiJyBCx2RFQrRsWHwLuBC87nl+L7wxdFx7F5Px3PQerlYnhoVRhzT6joOETkIFjsiKhW/HnU7rPfUzlqdxNWq4zPfq8crXvmnjB4crSOiGoJix0R1ZpRXSpH7c7ll2LjEY7a3cjPJ3KQnFMEd40Kz9wTJjoOETkQFjsiqjUNNCqM615ZVOb8ngaLlRvb/JXZYsWsX1IAAM/cEwqdG0friKj2sNgRUa0aHR8KLzc10vNK8ANH7a7x7cELSM8rgXcDFzzbg1uHEVHtYrEjolrlrlHh2aq9Tmf/eprr2v1JeYUFs3+tnFs36d4I3glLRLWOxY6Iat2YrqFo5K7BufxSfL0/Q3Qcm7F89znkGMoR5OWKEXFNRcchIgfEYkdEta6BRoUp9zUHAHzyayqKyisEJxJPX1aBudvOAACm3NccWjX3hCWi2sdiR0R14rFOwQhv3AD5JSYsSEgXHUe4hdvPQF9Wgea+7hgW3UR0HCJyUCx2RFQn1EoFXh3QCgCweGc6cvTlghOJc9lQjiU7zwIA/t6/JZQKSXAiInJULHZEVGf6tfFDp9CGKK+w4qMtKaLjCPPp76kor7AiuqkX+rbxEx2HiBwYix0R1RlJkjB9UGsAlct8JOcYBCeqf+fySrB6fyYA4NUBrSBJHK0jorrDYkdEdSq6aUMMaucPqwy891Oy6Dj17sMtp2G2yujVsjHiwn1ExyEiB8diR0R17pX+raBSSNiWkotdaXmi49Sb41n66kWaX+nfSnAaInIGLHZEVOdCGzXAyC4hAICZP52C1Um2GvugauuwwR0D0SbQU3AaInIGLHZEVC+e7x0Bd40Kx7MM2OgEW43tSM1FwulcqBQSXu7bUnQcInISLHZEVC983DWY0KsZgMqRrPIKi+BEdafCYsVbP5wEULl3blMfN8GJiMhZsNgRUb155p4w+HtqkVVYhi/3nBcdp86s2HMeaZeL4dPABS9W7cBBRFQfWOyIqN64uigxtV8LAMBnv6eisNQkOFHtyys2YvaW0wAqFyPWuaoFJyIiZ8JiR0T1anh0E7Ty94Ch3IxZmx1v0eJZv6SgyGhGZJAnHokNFh2HiJwMix0R1SulQsIbD7YBAHy1LwNJGVcEJ6o9xy7osSaxcjHifz3YlluHEVG9Y7EjonrXtVkjDIsOgiwD09cfQ4XFKjrSXbNaZby58ThkGRjSMRCxod6iIxGRE2KxIyIhXh/UGl5uaiTnFGHZrrOi49y1r/Zn4FBGIdxclHhtYGvRcYjISbHYEZEQPu4azKgqQB9vScWFK6WCE925bH0Z3q/aLu3v/VvCX6cVnIiInBWLHREJ80hsE3QO80ZZhQVvfn8Csmx/O1LIsox/bjiOYqMZUU29MDo+VHQkInJiLHZEJIwkSXh3aCTUSgm/JV/GLydyREe6bT8ey8avpy5DrZTw/vD2vGGCiIRisSMioSJ8PfBcj8odKd7ceAL60grBiWruSokJ/9p4AgAwsVcEWvh5CE5ERM6OxY6IhJvcOwKhPm64ZDBixoZjdnNJ9p0fTyKv2IQIX3dMvLeZ6DhERCx2RCSeVq3E7MejoFJI+PFoNr49eEF0pFvadCwb6w9lQZKA94e3g0alFB2JiIjFjohsQ8dgL7zUt3K7sTc3nsDZvBLBiW4sW1+G6euPAQAm9GyGmBCuWUdEtoHFjohsxviezdAl3BulJgteXJ0Ek9n2Fi62WmVMXXME+rIKtG+iw5T7WoiORERUjcWOiGyGUiHh48c6QueqxtELeny05bToSNf47Pc07EnPh6taidmPdYSLir9Gich28DcSEdmUAJ0r3h/eDgCwYPsZ7EzNE5zof35PvoTZv1WWzbcHt0V4Y3fBiYiIrsZiR0Q2Z0BkAJ7o3BSyDEz++hDO54ufb3curwQvrj4MWQZGdmmKR2KDRUciIroGix0R2aQ3H2yDDk10KCytwNjliTCUi1vfrsRoxnNfHkRRuRkxIQ3xxgNthWUhIroZFjsisklatRILR8fC31OLtMvFeH5VEsyW+r+ZwmS2YvzKg0i5VITGHhrMHRHNeXVEZLP424mIbJafpxaLn4qFVq1AwulcvPLtUVit9bd4sdUq4+/fHsGO1Dy4qpVYNDoWfp7aenv/RES3i8WOiGxaZJAOnz0RDaVCwvqkLPzj++P1sjOFLMt464cT+P7wRagUEuaNjEbHYK86f79ERHeDxY6IbF7fNn74+LGOkCRg1b4MvPH9CVjqcOTOapUx47vjWL7nPADgg0fao1dL3zp7f0REtYXFjojswkMdAvH+8PYAgC/3nsfzXx9CeYWl1t9PeYUFL645jK/3Z0AhAbMe6YChUU1q/f0QEdUFFjsishuPxgbjsyei4KJUYNOxHIxYvA9ZhWW19vazCsvw8Pzd+OHIRSgVEj55PAoPx7DUEZH9kOT6mKxCRFSLdp/Jw3MrDqLIaIbOVY33h7fHgEj/G55vMBig0+mg1+vh6el53XO2Jl/G3789grxiE7wbuODzJ6MR38ynrj4EIqI6wRE7Iqp3c+fORVhYGLRaLWJiYrBjx46bnp+QkICYmBhotVqEh4fj6JZv8X8vdEOHJjroyyowfuVBTPzqIM7m3f5CxlmFZXhxdRKe/uIA8opNaBPgiY2T72GpIyK7xGJHRPVqzZo1mDJlCl5//XUkJSWhe/fuGDhwIDIyMq57/tmzZzFo0CB0794dSUlJmDFjBl544QUkbvsZa8d3xXM9wiFJwKZjOej7UQKmrz+KpIwrN71zVpZlnLxowOvfHUPvWdvw/eGLkCRgXLcwrJ/YFU0autXVh09EVKd4KZaI6lVcXByio6Mxb9686mOtW7fGkCFDMHPmzGvOf/XVV7Fx40acOnWq+tj48eNx5MgR7NmzBwCQnGPA+z8lY2tKbvU5IT5uiA3xRusAD6gs5Xj63rb4/JcjyCwG9qUXIP1Po3txYd745wNtEBmkq4sPmYio3qhqcpIsyygqKqrrLETk4EwmExITE/HCCy/AYDBUH+/Zsye2b99+1bE/7NixAz179rzqdd27d8fixYuRn58PtVqNQDfgk+GtkHjWF2sPZuK35Ms4e7EUZy/mAQCsxlIAwLsbkqDQVI7GqVUK9GzeCCPjQhAT2hCSJF33/RMR2QoPDw9IknTTc2o0YvfHxGMiIiIiEuNmN4D9oUbFjiN2tcdgMCA4OBiZmZm3/OKQbeHX7u5lZ2ejVatW2LJlCzp37lx9/IMPPsDq1atx8ODBa54TFRWFkSNH4uWXX64+tnfvXvTv3x+nT5+Gn5/fNc8xGo0wGo1Xvd/OnTvj5MmTCAoKquWPiuoSf+7sF792ta8mI3Y1uhQrSRK/KLXM09OTn1M7xa/dndNqtVAqlSgqKrrqc2gwGBAYGHjdz2tQUBAKCwuvel1JSQlUKhVCQ0OhVqtr/P49PDz4tbNT/LmzX/za1S/eFUtE9cbFxQUxMTHYsmXLVce3bNmCrl27Xvc58fHx15y/efNmxMbG3lapIyJyBix2RFSvpk6disWLF2Pp0qU4deoUXnrpJWRkZGD8+PEAgOnTp2P06NHV548fPx7nz5/H1KlTcerUKSxduhRLlizBtGnTRH0IREQ2q0aXYqn2aDQavPnmm9BoNKKj0G3i1652PPbYY8jPz8fbb7+N7OxsREZGYtOmTQgJCQFQOR/uz2vahYWFYdOmTXjppZfw+eefIzAwEJ9++imGDx9e4/f5x9eMXzv7w587+8WvnRhcx46IHF5NthQjInIEvBRLRERE5CBY7IiIiIgcBIsdERERkYNgsSMiIiJyECx2NsBoNKJjx46QJAmHDx8WHYdu4dy5cxg7dizCwsLg6uqKZs2a4c0334TJZBIdja5j7ty5aNeuHQCgR48e2LFjh+BEdCszZ85Ep06d4OHhAV9fXwwZMgQpKSmiY9EdmDlzJiRJwpQpU0RHcRosdjbglVdeQWBgoOgYVEPJycmwWq1YsGABTpw4gY8//hjz58/HjBkzREejv1izZg2mTJlSveZdfHw8Bg4ceNVyKmR7EhISMGnSJOzduxdbtmyB2WxGv379UFJSIjoa3YYDBw5g4cKFaN++vegoToXLnQj2008/YerUqVi3bh3atm2LpKQkdOzYUXQsuk0ffPAB5s2bh/T0dNFR6E/i4uIQHR2N999/v3q5k7i4OAwZMgQzZ84UHY9qKDc3F76+vkhISECPHj1Ex6EaKC4uRnR0NObOnYt///vf6NixI2bPni06llPgiJ1Aly5dwrPPPosvv/wSbm5uouPQXdDr9fD29hYdg/7EZDLh4MGD6Nev31XH+/Xrh927dwtKRXdCr9cDAH/G7MikSZNw//3347777hMdxelw5wlBZFnGmDFjMH78eMTGxuLcuXOiI9EdOnPmDD777DN8+OGHoqPQn+Tl5cFiscDPz++q435+fsjJyRGUim6XLMuYOnUqunXrhsjISNFxqAZWr16NQ4cO4cCBA6KjOCWO2NWyf/3rX5Ak6aaPxMREfPbZZzAYDJg+fbroyFSlpl+7P7t48SIGDBiARx55BOPGjROUnG5GkqSrXpZl+ZpjZLsmT56Mo0eP4uuvvxYdhWogMzMTL774IlauXAmtVis6jlPiHLtalpeXh7y8vJueExoaiscffxw//PDDVX9gLBYLlEolRowYgeXLl9d1VPqLmn7t/vhldfHiRdx7772Ii4vDF198AYWC/yfZEpPJBDc3N6xduxZ9+vSpnmP3z3/+E4cPH0ZCQoLoiHQLzz//PDZs2IDt27cjLCxMdByqgQ0bNmDo0KFQKpXVxywWCyRJgkKhgNFovOp1VPtY7ATJyMiAwWCofvnixYvo378/vv32W8TFxaFJkyYC09GtZGVl4d5770VMTAxWrlzJX1Q2Ki4uDjExMXjvvfeqi12XLl0wePBg3jxhw2RZxvPPP4/vvvsO27ZtQ/PmzUVHohoqKirC+fPnrzr29NNPo1WrVnj11Vd5Ob0ecI6dIE2bNr3qZXd3dwBAs2bNWOps3MWLF9GrVy80bdoUs2bNQm5ubvXr/P39BSajv5o6dSpGjRqFtm3bAgBee+01ZGRkYPz48YKT0c1MmjQJq1atwvfffw8PD4/qOZE6nQ6urq6C09HNeHh4XFPeGjRoAB8fH5a6esJiR3SbNm/ejLS0NKSlpV1TwjkAblsee+wx5Ofn4/3334darcbevXuxadMmhISEiI5GNzFv3jwAQK9eva46vmzZMowZM6b+AxHZEV6KJSIiInIQnO1NRERE5CBY7IiIiIgcBIsdERERkYNgsSMiIiJyECx2RERERA6CxY6IiIjIQbDYERERETkIFjsiIiIiB8FiR0REROQgWOyIiIiIHASLHREREZGDYLEjIof19ddfQ6vVIisrq/rYuHHj0L59e+j1eoHJiIjqhiTLsiw6BBFRXZBlGR07dkT37t0xZ84cvPXWW1i8eDH27t2LoKAg0fGIiGqdSnQAIqK6IkkS/vOf/+Dhhx9GYGAgPvnkE+zYsYOljogcFkfsiMjhRUdH48SJE9i8eTN69uwpOg4RUZ3hHDsicmi//PILkpOTYbFY4OfnJzoOEVGd4ogdETmsQ4cOoVevXvj888+xevVquLm5Ye3ataJjERHVGc6xIyKHdO7cOdx///147bXXMGrUKLRp0wadOnXCwYMHERMTIzoeEVGd4IgdETmcgoIC3HPPPejRowcWLFhQfXzw4MEwGo34+eefBaYjIqo7LHZEREREDoI3TxARERE5CBY7IiIiIgfBYkdERETkIFjsiIiIiBwEix0RERGRg2CxIyIiInIQLHZEREREDoLFjoiIiMhBsNgREREROQgWOyIiIiIHwWJHRERE5CD+H8yfF5N2UBn5AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2be62377dd0>"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,-5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport excel_function_package.linear_regression\n",
    "from excel_function_package.linear_regression import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr=LinearRegression(Data([0,2.83,3.26,3.56,3.71,4.11,4.17,4.29]),Data([11.8,10.6,10.4,10.3,10.2,10.1,10,9.95]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2.83, 3.26, 3.56, 3.71, 4.11, 4.17, 4.29]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11.8, 10.6, 10.4, 10.3, 10.2, 10.1, 10, 9.95]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11.8013321544625, -0.426558319926714]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1 & 1 & 1 & 1 & 1\\\\0 & 2.83 & 3.26 & 3.56 & 3.71 & 4.11 & 4.17 & 4.29\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[1,    1,    1,    1,    1,    1,    1,    1],\n",
       "[0, 2.83, 3.26, 3.56, 3.71, 4.11, 4.17, 4.29]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([ones(1, 8), Matrix(lr.X)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decimal2rational(d,n=2):\n",
    "    return Rational(floor(Decimal(d)*10**n),10**n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_want(data):\n",
    "    l=[]\n",
    "    for i in data:\n",
    "        l.append(decimal2rational(i))\n",
    "    return Data(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lr=LinearRegression(get_want(Data([0,2.83,3.26,3.56,3.71,4.11,4.17,4.29])),get_want(Data([11.8,10.6,10.4,10.3,10.2,10.1,10,9.95])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[323709366/27427375, -469189/1097095]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.coeffs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 11.8024187877987$"
      ],
      "text/plain": [
       "11.8024187877987"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(lr.coeffs[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -0.427664878611242$"
      ],
      "text/plain": [
       "-0.427664878611242"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(lr.coeffs[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 283/100, 163/50, 89/25, 371/100, 411/100, 417/100, 429/100]]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[59/5, 53/5, 52/5, 103/10, 1019/100, 101/10, 10, 497/50]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lr.Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from decimal import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('411.0000000000000319744231092')"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Decimal(4.11)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(63,-24,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{21}, \\frac{1}{3}\\right\\}$"
      ],
      "text/plain": [
       "{1/21, 1/3}"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.roots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -2 + 2 \\sqrt{2}$"
      ],
      "text/plain": [
       "-2 + 2*sqrt(2)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(function_range((x**2+1)/(x+1),x,Interval(0,oo)).inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2*x-sqrt(x**2-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x - \\sqrt{x^{2} - 1}$"
      ],
      "text/plain": [
       "2*x - sqrt(x**2 - 1)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x2e1cd994210>"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,1,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1,x2=symbols(\"x1:3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x_{1} - 2 x_{2} - \\sqrt{x_{1}^{2} - 1} + \\sqrt{x_{2}^{2} - 1}$"
      ],
      "text/plain": [
       "2*x1 - 2*x2 - sqrt(x1**2 - 1) + sqrt(x2**2 - 1)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(expr.subs(x,x1)-expr.subs(x,x2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{x - 2 \\sqrt{x^{2} - 1}}{\\sqrt{\\left(x - 1\\right) \\left(x + 1\\right)}}$"
      ],
      "text/plain": [
       "-(x - 2*sqrt(x**2 - 1))/sqrt((x - 1)*(x + 1))"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h=Hyperbola(Point(0,0),a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1 - \\frac{y^{2}}{b^{2}} + \\frac{x^{2}}{a^{2}}$"
      ],
      "text/plain": [
       "-1 - y**2/b**2 + x**2/a**2"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k =symbols(\"k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k in Reals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x-h.foci[1].x),x=x,y=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(h,l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{\\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} + k \\sqrt{a^{2} + b^{2}}}{k}, \\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D((a*b**2*k*sqrt(k**2 + 1)/(a**2*k**2 - b**2) + b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2) + k*sqrt(a**2 + b**2))/k, a*b**2*k*sqrt(k**2 + 1)/(a**2*k**2 - b**2) + b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2))"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- \\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} + k \\sqrt{a^{2} + b^{2}}}{k}, - \\frac{a b^{2} k \\sqrt{k^{2} + 1}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D((-a*b**2*k*sqrt(k**2 + 1)/(a**2*k**2 - b**2) + b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2) + k*sqrt(a**2 + b**2))/k, -a*b**2*k*sqrt(k**2 + 1)/(a**2*k**2 - b**2) + b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2))"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=(A+B)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{a^{2} k^{2} \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}, \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D(a**2*k**2*sqrt(a**2 + b**2)/(a**2*k**2 - b**2), b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2))"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=symbols(\"d\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(d,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=A.distance(B)/2-C.distance(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a b^{2} \\left(k^{2} + 1\\right) - \\sqrt{b^{4} k^{2} \\left(a^{2} + b^{2}\\right) + \\left(a^{2} k^{2} \\sqrt{a^{2} + b^{2}} - d \\left(a^{2} k^{2} - b^{2}\\right)\\right)^{2}}}{\\left|{a^{2} k^{2} - b^{2}}\\right|}$"
      ],
      "text/plain": [
       "(a*b**2*(k**2 + 1) - sqrt(b**4*k**2*(a**2 + b**2) + (a**2*k**2*sqrt(a**2 + b**2) - d*(a**2*k**2 - b**2))**2))/Abs(a**2*k**2 - b**2)"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a b^{2} \\left(k^{2} + 1\\right)}{\\left|{a^{2} k^{2} - b^{2}}\\right|}$"
      ],
      "text/plain": [
       "a*b**2*(k**2 + 1)/Abs(a**2*k**2 - b**2)"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(A.distance(B)/2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{a^{2} k^{2} \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}, \\frac{b^{2} k \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}}\\right)$"
      ],
      "text/plain": [
       "Point2D(a**2*k**2*sqrt(a**2 + b**2)/(a**2*k**2 - b**2), b**2*k*sqrt(a**2 + b**2)/(a**2*k**2 - b**2))"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{4} k^{2} + a^{2} b^{2} k^{2} + a^{2} b^{2} + a^{2} d^{2} k^{2} - 2 a^{2} d k^{2} \\sqrt{a^{2} + b^{2}} - b^{4} k^{2} - b^{2} d^{2}}{a^{2} k^{2} - b^{2}}$"
      ],
      "text/plain": [
       "(a**4*k**2 + a**2*b**2*k**2 + a**2*b**2 + a**2*d**2*k**2 - 2*a**2*d*k**2*sqrt(a**2 + b**2) - b**4*k**2 - b**2*d**2)/(a**2*k**2 - b**2)"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify((A-P).x*(B-P).x+(A-P).y*(B-P).y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{\\frac{a^{2} k^{2} \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} - \\frac{b^{2} \\sqrt{a^{2} k^{4} + a^{2} k^{2} + a^{2} - b^{2} k^{2}}}{a^{2} k^{2} - b^{2}}, \\frac{a^{2} k^{2} \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} + \\frac{b^{2} \\sqrt{a^{2} k^{4} + a^{2} k^{2} + a^{2} - b^{2} k^{2}}}{a^{2} k^{2} - b^{2}}\\right\\}$"
      ],
      "text/plain": [
       "Intersection({a**2*k**2*sqrt(a**2 + b**2)/(a**2*k**2 - b**2) - b**2*sqrt(a**2*k**4 + a**2*k**2 + a**2 - b**2*k**2)/(a**2*k**2 - b**2), a**2*k**2*sqrt(a**2 + b**2)/(a**2*k**2 - b**2) + b**2*sqrt(a**2*k**4 + a**2*k**2 + a**2 - b**2*k**2)/(a**2*k**2 - b**2)}, Reals)"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,d,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer1,answer2=_.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\cdot \\left(2 k^{2} - 3 \\sqrt{k^{4} - 2 k^{2} + 1}\\right)}{k^{2} - 3}$"
      ],
      "text/plain": [
       "2*(2*k**2 - 3*sqrt(k**4 - 2*k**2 + 1))/(k**2 - 3)"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31mCanceled future for execute_request message before replies were done"
     ]
    }
   ],
   "source": [
    "simplify(answer2.subs({b:a*sqrt(3)}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{2} k^{2} \\sqrt{a^{2} + b^{2}}}{a^{2} k^{2} - b^{2}} - \\frac{b^{2} \\sqrt{a^{2} k^{4} + a^{2} k^{2} + a^{2} - b^{2} k^{2}}}{a^{2} k^{2} - b^{2}}$"
      ],
      "text/plain": [
       "a**2*k**2*sqrt(a**2 + b**2)/(a**2*k**2 - b**2) - b**2*sqrt(a**2*k**4 + a**2*k**2 + a**2 - b**2*k**2)/(a**2*k**2 - b**2)"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 9.44483117612978$"
      ],
      "text/plain": [
       "9.44483117612978"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N((2-log(75,10))/(2-log(97,10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 9.44483117612978$"
      ],
      "text/plain": [
       "9.44483117612978"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N((2-log(75,10))/(2-log(97,10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 吉安高二上学期期末教学质量检测"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1=Line(5*x-12*y+2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=l1.arbitrary_point().subs(l1.arbitrary_point().x,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{7}{26}$"
      ],
      "text/plain": [
       "7/26"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P.distance(Line(10*x-24*y-3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "para=Parabola(Point(4,0),Line(x+4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 16 x - y^{2}$"
      ],
      "text/plain": [
       "16*x - y**2"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "para.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{5}$"
      ],
      "text/plain": [
       "sqrt(5)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Point(0,4).distance(Point(2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Circle(Point(1,0),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{x \\left(2 - \\sqrt{2}\\right)}{2} + \\frac{y \\left(2 - \\sqrt{2}\\right)}{2} + \\frac{\\sqrt{2}}{2}$"
      ],
      "text/plain": [
       "-x*(2 - sqrt(2))/2 + y*(2 - sqrt(2))/2 + sqrt(2)/2"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(c.tangent_lines(Point(sqrt(2),-1))[1].equation())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y + 1\n",
      "x*(-1 + sqrt(2)/2) + y*(1 - sqrt(2)/2) + sqrt(2)/2\n"
     ]
    }
   ],
   "source": [
    "for l in _:\n",
    "    print(l.equation())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{1}{21}, \\frac{1}{3}\\right\\}$"
      ],
      "text/plain": [
       "{1/21, 1/3}"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(1/(9*x)+7*x-Rational(8,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on Integer in module sympy.core.numbers object:\n",
      "\n",
      "class Integer(Rational)\n",
      " |  Integer(i)\n",
      " |  \n",
      " |  Represents integer numbers of any size.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Integer\n",
      " |  >>> Integer(3)\n",
      " |  3\n",
      " |  \n",
      " |  If a float or a rational is passed to Integer, the fractional part\n",
      " |  will be discarded; the effect is of rounding toward zero.\n",
      " |  \n",
      " |  >>> Integer(3.8)\n",
      " |  3\n",
      " |  >>> Integer(-3.8)\n",
      " |  -3\n",
      " |  \n",
      " |  A string is acceptable input if it can be parsed as an integer:\n",
      " |  \n",
      " |  >>> Integer(\"9\" * 20)\n",
      " |  99999999999999999999\n",
      " |  \n",
      " |  It is rarely needed to explicitly instantiate an Integer, because\n",
      " |  Python integers are automatically converted to Integer when they\n",
      " |  are used in SymPy expressions.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Integer\n",
      " |      Rational\n",
      " |      Number\n",
      " |      sympy.core.expr.AtomicExpr\n",
      " |      sympy.core.basic.Atom\n",
      " |      sympy.core.expr.Expr\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __abs__(self)\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |      # TODO make it decorator + bytecodehacks?\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __ceil__(self)\n",
      " |  \n",
      " |  __divmod__(self, other)\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from https://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __floor__(self)\n",
      " |  \n",
      " |  __floordiv__(self, other)\n",
      " |  \n",
      " |  __ge__(self, other)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __gt__(self, other)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __index__(self)\n",
      " |  \n",
      " |  __int__(self)\n",
      " |      # Arithmetic operations are here for efficiency\n",
      " |  \n",
      " |  __invert__(self)\n",
      " |  \n",
      " |  __le__(self, other)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __lshift__(self, other)\n",
      " |      # These bitwise operations (__lshift__, __rlshift__, ..., __invert__) are defined\n",
      " |      # for Integer only and not for general SymPy expressions. This is to achieve\n",
      " |      # compatibility with the numbers.Integral ABC which only defines these operations\n",
      " |      # among instances of numbers.Integral. Therefore, these methods check explicitly for\n",
      " |      # integer types rather than using sympify because they should not accept arbitrary\n",
      " |      # symbolic expressions and there is no symbolic analogue of numbers.Integral's\n",
      " |      # bitwise operations.\n",
      " |  \n",
      " |  __lt__(self, other)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mod__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __neg__(self)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |      Return self|value.\n",
      " |  \n",
      " |  __radd__(self, other)\n",
      " |  \n",
      " |  __rand__(self, other)\n",
      " |  \n",
      " |  __rdivmod__(self, other)\n",
      " |  \n",
      " |  __rfloordiv__(self, other)\n",
      " |  \n",
      " |  __rlshift__(self, other)\n",
      " |  \n",
      " |  __rmod__(self, other)\n",
      " |  \n",
      " |  __rmul__(self, other)\n",
      " |  \n",
      " |  __ror__(self, other)\n",
      " |      Return value|self.\n",
      " |  \n",
      " |  __rrshift__(self, other)\n",
      " |  \n",
      " |  __rshift__(self, other)\n",
      " |  \n",
      " |  __rsub__(self, other)\n",
      " |  \n",
      " |  __rxor__(self, other)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  as_numer_denom(self)\n",
      " |      Return the numerator and the denominator of an expression.\n",
      " |      \n",
      " |      expression -> a/b -> a, b\n",
      " |      \n",
      " |      This is just a stub that should be defined by\n",
      " |      an object's class methods to get anything else.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      normal: return ``a/b`` instead of ``(a, b)``\n",
      " |  \n",
      " |  ceiling(self)\n",
      " |  \n",
      " |  floor(self)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, i)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __annotations__ = {}\n",
      " |  \n",
      " |  default_assumptions = {'commutative': True, 'real': True, 'imaginary':...\n",
      " |  \n",
      " |  is_Integer = True\n",
      " |  \n",
      " |  is_algebraic = True\n",
      " |  \n",
      " |  is_commutative = True\n",
      " |  \n",
      " |  is_complex = True\n",
      " |  \n",
      " |  is_extended_real = True\n",
      " |  \n",
      " |  is_finite = True\n",
      " |  \n",
      " |  is_hermitian = True\n",
      " |  \n",
      " |  is_imaginary = False\n",
      " |  \n",
      " |  is_infinite = False\n",
      " |  \n",
      " |  is_integer = True\n",
      " |  \n",
      " |  is_irrational = False\n",
      " |  \n",
      " |  is_noninteger = False\n",
      " |  \n",
      " |  is_number = True\n",
      " |  \n",
      " |  is_rational = True\n",
      " |  \n",
      " |  is_real = True\n",
      " |  \n",
      " |  is_transcendental = False\n",
      " |  \n",
      " |  q = 1\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Rational:\n",
      " |  \n",
      " |  __rtruediv__(self, other)\n",
      " |  \n",
      " |  __truediv__(self, other)\n",
      " |  \n",
      " |  as_coeff_Add(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a summation.\n",
      " |  \n",
      " |  as_coeff_Mul(self, rational=False)\n",
      " |      Efficiently extract the coefficient of a product.\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      Return the tuple (R, self/R) where R is the positive Rational\n",
      " |      extracted from self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (S(-3)/2).as_content_primitive()\n",
      " |      (3/2, -1)\n",
      " |      \n",
      " |      See docstring of Expr.as_content_primitive for more examples.\n",
      " |  \n",
      " |  factors(self, limit=None, use_trial=True, use_rho=False, use_pm1=False, verbose=False, visual=False)\n",
      " |      A wrapper to factorint which return factors of self that are\n",
      " |      smaller than limit (or cheap to compute). Special methods of\n",
      " |      factoring are disabled by default so that only trial division is used.\n",
      " |  \n",
      " |  gcd(self, other)\n",
      " |      Compute GCD of `self` and `other`.\n",
      " |  \n",
      " |  lcm(self, other)\n",
      " |      Compute LCM of `self` and `other`.\n",
      " |  \n",
      " |  limit_denominator(self, max_denominator=1000000)\n",
      " |      Closest Rational to self with denominator at most max_denominator.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Rational\n",
      " |      >>> Rational('3.141592653589793').limit_denominator(10)\n",
      " |      22/7\n",
      " |      >>> Rational('3.141592653589793').limit_denominator(100)\n",
      " |      311/99\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Rational:\n",
      " |  \n",
      " |  denominator\n",
      " |  \n",
      " |  numerator\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Rational:\n",
      " |  \n",
      " |  p\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Rational:\n",
      " |  \n",
      " |  is_Rational = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Number:\n",
      " |  \n",
      " |  __float__(self)\n",
      " |  \n",
      " |  as_coeff_add(self, *deps)\n",
      " |      Return the tuple (c, args) where self is written as an Add, ``a``.\n",
      " |      \n",
      " |      c should be a Rational added to any terms of the Add that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other terms of ``a``; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is an Add or not but\n",
      " |      you want to treat self as an Add or if you want to process the\n",
      " |      individual arguments of the tail of self as an Add.\n",
      " |      \n",
      " |      - if you know self is an Add and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail.\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_add()\n",
      " |      (3, ())\n",
      " |      >>> (3 + x).as_coeff_add()\n",
      " |      (3, (x,))\n",
      " |      >>> (3 + x + y).as_coeff_add(x)\n",
      " |      (y + 3, (x,))\n",
      " |      >>> (3 + y).as_coeff_add(x)\n",
      " |      (y + 3, ())\n",
      " |  \n",
      " |  as_coeff_mul(self, *deps, rational=True, **kwargs)\n",
      " |      Return the tuple (c, args) where self is written as a Mul, ``m``.\n",
      " |      \n",
      " |      c should be a Rational multiplied by any factors of the Mul that are\n",
      " |      independent of deps.\n",
      " |      \n",
      " |      args should be a tuple of all other factors of m; args is empty\n",
      " |      if self is a Number or if self is independent of deps (when given).\n",
      " |      \n",
      " |      This should be used when you do not know if self is a Mul or not but\n",
      " |      you want to treat self as a Mul or if you want to process the\n",
      " |      individual arguments of the tail of self as a Mul.\n",
      " |      \n",
      " |      - if you know self is a Mul and want only the head, use self.args[0];\n",
      " |      - if you do not want to process the arguments of the tail but need the\n",
      " |        tail then use self.as_two_terms() which gives the head and tail;\n",
      " |      - if you want to split self into an independent and dependent parts\n",
      " |        use ``self.as_independent(*deps)``\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (S(3)).as_coeff_mul()\n",
      " |      (3, ())\n",
      " |      >>> (3*x*y).as_coeff_mul()\n",
      " |      (3, (x, y))\n",
      " |      >>> (3*x*y).as_coeff_mul(x)\n",
      " |      (3*y, (x,))\n",
      " |      >>> (3*y).as_coeff_mul(x)\n",
      " |      (3*y, ())\n",
      " |  \n",
      " |  cofactors(self, other)\n",
      " |      Compute GCD and cofactors of `self` and `other`.\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |      Return True if self has -1 as a leading factor or has\n",
      " |      more literal negative signs than positive signs in a sum,\n",
      " |      otherwise False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = x - y\n",
      " |      >>> {i.could_extract_minus_sign() for i in (e, -e)}\n",
      " |      {False, True}\n",
      " |      \n",
      " |      Though the ``y - x`` is considered like ``-(x - y)``, since it\n",
      " |      is in a product without a leading factor of -1, the result is\n",
      " |      false below:\n",
      " |      \n",
      " |      >>> (x*(y - x)).could_extract_minus_sign()\n",
      " |      False\n",
      " |      \n",
      " |      To put something in canonical form wrt to sign, use `signsimp`:\n",
      " |      \n",
      " |      >>> from sympy import signsimp\n",
      " |      >>> signsimp(x*(y - x))\n",
      " |      -x*(x - y)\n",
      " |      >>> _.could_extract_minus_sign()\n",
      " |      True\n",
      " |  \n",
      " |  invert(self, other, *gens, **args)\n",
      " |      Return the multiplicative inverse of ``self`` mod ``g``\n",
      " |      where ``self`` (and ``g``) may be symbolic expressions).\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      sympy.core.numbers.mod_inverse, sympy.polys.polytools.invert\n",
      " |  \n",
      " |  is_constant(self, *wrt, **flags)\n",
      " |      Return True if self is constant, False if not, or None if\n",
      " |      the constancy could not be determined conclusively.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If an expression has no free symbols then it is a constant. If\n",
      " |      there are free symbols it is possible that the expression is a\n",
      " |      constant, perhaps (but not necessarily) zero. To test such\n",
      " |      expressions, a few strategies are tried:\n",
      " |      \n",
      " |      1) numerical evaluation at two random points. If two such evaluations\n",
      " |      give two different values and the values have a precision greater than\n",
      " |      1 then self is not constant. If the evaluations agree or could not be\n",
      " |      obtained with any precision, no decision is made. The numerical testing\n",
      " |      is done only if ``wrt`` is different than the free symbols.\n",
      " |      \n",
      " |      2) differentiation with respect to variables in 'wrt' (or all free\n",
      " |      symbols if omitted) to see if the expression is constant or not. This\n",
      " |      will not always lead to an expression that is zero even though an\n",
      " |      expression is constant (see added test in test_expr.py). If\n",
      " |      all derivatives are zero then self is constant with respect to the\n",
      " |      given symbols.\n",
      " |      \n",
      " |      3) finding out zeros of denominator expression with free_symbols.\n",
      " |      It will not be constant if there are zeros. It gives more negative\n",
      " |      answers for expression that are not constant.\n",
      " |      \n",
      " |      If neither evaluation nor differentiation can prove the expression is\n",
      " |      constant, None is returned unless two numerical values happened to be\n",
      " |      the same and the flag ``failing_number`` is True -- in that case the\n",
      " |      numerical value will be returned.\n",
      " |      \n",
      " |      If flag simplify=False is passed, self will not be simplified;\n",
      " |      the default is True since self should be simplified before testing.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, Sum, S, pi\n",
      " |      >>> from sympy.abc import a, n, x, y\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> S(2).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, 10)).is_constant()\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant()\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(y)\n",
      " |      True\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(n)\n",
      " |      False\n",
      " |      >>> Sum(x, (x, 1, n)).is_constant(x)\n",
      " |      True\n",
      " |      >>> eq = a*cos(x)**2 + a*sin(x)**2 - a\n",
      " |      >>> eq.is_constant()\n",
      " |      True\n",
      " |      >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0\n",
      " |      True\n",
      " |      \n",
      " |      >>> (0**x).is_constant()\n",
      " |      False\n",
      " |      >>> x.is_constant()\n",
      " |      False\n",
      " |      >>> (x**x).is_constant()\n",
      " |      False\n",
      " |      >>> one = cos(x)**2 + sin(x)**2\n",
      " |      >>> one.is_constant()\n",
      " |      True\n",
      " |      >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1\n",
      " |      True\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from Number:\n",
      " |  \n",
      " |  class_key() from builtins.type\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Number:\n",
      " |  \n",
      " |  is_Number = True\n",
      " |  \n",
      " |  kind = NumberKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.expr.AtomicExpr:\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |      Like ``free_symbols``, but returns the free symbols only if\n",
      " |      they are contained in an expression node.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (x + y).expr_free_symbols # doctest: +SKIP\n",
      " |      {x, y}\n",
      " |      \n",
      " |      If the expression is contained in a non-expression object, do not return\n",
      " |      the free symbols. Compare:\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> t = Tuple(x + y)\n",
      " |      >>> t.expr_free_symbols # doctest: +SKIP\n",
      " |      set()\n",
      " |      >>> t.free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.AtomicExpr:\n",
      " |  \n",
      " |  is_Atom = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Atom:\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  xreplace(self, rule, hack2=False)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  __complex__(self)\n",
      " |  \n",
      " |  __format__(self, format_spec: 'str')\n",
      " |      Default object formatter.\n",
      " |  \n",
      " |  __pos__(self)\n",
      " |  \n",
      " |  __pow__(self, other, mod=None) -> 'Expr'\n",
      " |  \n",
      " |  __round__ = round(self, n=None)\n",
      " |  \n",
      " |  __rpow__(self, other)\n",
      " |  \n",
      " |  __trunc__(self)\n",
      " |  \n",
      " |  adjoint(self)\n",
      " |  \n",
      " |  apart(self, x=None, **args)\n",
      " |      See the apart function in sympy.polys\n",
      " |  \n",
      " |  args_cnc(self, cset=False, warn=True, split_1=True)\n",
      " |      Return [commutative factors, non-commutative factors] of self.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      self is treated as a Mul and the ordering of the factors is maintained.\n",
      " |      If ``cset`` is True the commutative factors will be returned in a set.\n",
      " |      If there were repeated factors (as may happen with an unevaluated Mul)\n",
      " |      then an error will be raised unless it is explicitly suppressed by\n",
      " |      setting ``warn`` to False.\n",
      " |      \n",
      " |      Note: -1 is always separated from a Number unless split_1 is False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, oo\n",
      " |      >>> A, B = symbols('A B', commutative=0)\n",
      " |      >>> x, y = symbols('x y')\n",
      " |      >>> (-2*x*y).args_cnc()\n",
      " |      [[-1, 2, x, y], []]\n",
      " |      >>> (-2.5*x).args_cnc()\n",
      " |      [[-1, 2.5, x], []]\n",
      " |      >>> (-2*x*A*B*y).args_cnc()\n",
      " |      [[-1, 2, x, y], [A, B]]\n",
      " |      >>> (-2*x*A*B*y).args_cnc(split_1=False)\n",
      " |      [[-2, x, y], [A, B]]\n",
      " |      >>> (-2*x*y).args_cnc(cset=True)\n",
      " |      [{-1, 2, x, y}, []]\n",
      " |      \n",
      " |      The arg is always treated as a Mul:\n",
      " |      \n",
      " |      >>> (-2 + x + A).args_cnc()\n",
      " |      [[], [x - 2 + A]]\n",
      " |      >>> (-oo).args_cnc() # -oo is a singleton\n",
      " |      [[-1, oo], []]\n",
      " |  \n",
      " |  as_base_exp(self) -> 'tuple[Expr, Expr]'\n",
      " |  \n",
      " |  as_coeff_exponent(self, x) -> 'tuple[Expr, Expr]'\n",
      " |      ``c*x**e -> c,e`` where x can be any symbolic expression.\n",
      " |  \n",
      " |  as_coefficient(self, expr)\n",
      " |      Extracts symbolic coefficient at the given expression. In\n",
      " |      other words, this functions separates 'self' into the product\n",
      " |      of 'expr' and 'expr'-free coefficient. If such separation\n",
      " |      is not possible it will return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import E, pi, sin, I, Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> E.as_coefficient(E)\n",
      " |      1\n",
      " |      >>> (2*E).as_coefficient(E)\n",
      " |      2\n",
      " |      >>> (2*sin(E)*E).as_coefficient(E)\n",
      " |      \n",
      " |      Two terms have E in them so a sum is returned. (If one were\n",
      " |      desiring the coefficient of the term exactly matching E then\n",
      " |      the constant from the returned expression could be selected.\n",
      " |      Or, for greater precision, a method of Poly can be used to\n",
      " |      indicate the desired term from which the coefficient is\n",
      " |      desired.)\n",
      " |      \n",
      " |      >>> (2*E + x*E).as_coefficient(E)\n",
      " |      x + 2\n",
      " |      >>> _.args[0]  # just want the exact match\n",
      " |      2\n",
      " |      >>> p = Poly(2*E + x*E); p\n",
      " |      Poly(x*E + 2*E, x, E, domain='ZZ')\n",
      " |      >>> p.coeff_monomial(E)\n",
      " |      2\n",
      " |      >>> p.nth(0, 1)\n",
      " |      2\n",
      " |      \n",
      " |      Since the following cannot be written as a product containing\n",
      " |      E as a factor, None is returned. (If the coefficient ``2*x`` is\n",
      " |      desired then the ``coeff`` method should be used.)\n",
      " |      \n",
      " |      >>> (2*E*x + x).as_coefficient(E)\n",
      " |      >>> (2*E*x + x).coeff(E)\n",
      " |      2*x\n",
      " |      \n",
      " |      >>> (E*(x + 1) + x).as_coefficient(E)\n",
      " |      \n",
      " |      >>> (2*pi*I).as_coefficient(pi*I)\n",
      " |      2\n",
      " |      >>> (2*I).as_coefficient(pi*I)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      coeff: return sum of terms have a given factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  as_coefficients_dict(self, *syms)\n",
      " |      Return a dictionary mapping terms to their Rational coefficient.\n",
      " |      Since the dictionary is a defaultdict, inquiries about terms which\n",
      " |      were not present will return a coefficient of 0.\n",
      " |      \n",
      " |      If symbols ``syms`` are provided, any multiplicative terms\n",
      " |      independent of them will be considered a coefficient and a\n",
      " |      regular dictionary of syms-dependent generators as keys and\n",
      " |      their corresponding coefficients as values will be returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import a, x, y\n",
      " |      >>> (3*x + a*x + 4).as_coefficients_dict()\n",
      " |      {1: 4, x: 3, a*x: 1}\n",
      " |      >>> _[a]\n",
      " |      0\n",
      " |      >>> (3*a*x).as_coefficients_dict()\n",
      " |      {a*x: 3}\n",
      " |      >>> (3*a*x).as_coefficients_dict(x)\n",
      " |      {x: 3*a}\n",
      " |      >>> (3*a*x).as_coefficients_dict(y)\n",
      " |      {1: 3*a*x}\n",
      " |  \n",
      " |  as_expr(self, *gens)\n",
      " |      Convert a polynomial to a SymPy expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = (x**2 + x*y).as_poly(x, y)\n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + x*y\n",
      " |      \n",
      " |      >>> sin(x).as_expr()\n",
      " |      sin(x)\n",
      " |  \n",
      " |  as_independent(self, *deps, **hint) -> 'tuple[Expr, Expr]'\n",
      " |      A mostly naive separation of a Mul or Add into arguments that are not\n",
      " |      are dependent on deps. To obtain as complete a separation of variables\n",
      " |      as possible, use a separation method first, e.g.:\n",
      " |      \n",
      " |      * separatevars() to change Mul, Add and Pow (including exp) into Mul\n",
      " |      * .expand(mul=True) to change Add or Mul into Add\n",
      " |      * .expand(log=True) to change log expr into an Add\n",
      " |      \n",
      " |      The only non-naive thing that is done here is to respect noncommutative\n",
      " |      ordering of variables and to always return (0, 0) for `self` of zero\n",
      " |      regardless of hints.\n",
      " |      \n",
      " |      For nonzero `self`, the returned tuple (i, d) has the\n",
      " |      following interpretation:\n",
      " |      \n",
      " |      * i will has no variable that appears in deps\n",
      " |      * d will either have terms that contain variables that are in deps, or\n",
      " |        be equal to 0 (when self is an Add) or 1 (when self is a Mul)\n",
      " |      * if self is an Add then self = i + d\n",
      " |      * if self is a Mul then self = i*d\n",
      " |      * otherwise (self, S.One) or (S.One, self) is returned.\n",
      " |      \n",
      " |      To force the expression to be treated as an Add, use the hint as_Add=True\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      -- self is an Add\n",
      " |      \n",
      " |      >>> from sympy import sin, cos, exp\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> (x + x*y).as_independent(x)\n",
      " |      (0, x*y + x)\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x)\n",
      " |      (y + z, 2*x*sin(x) + x)\n",
      " |      >>> (2*x*sin(x) + y + x + z).as_independent(x, y)\n",
      " |      (z, 2*x*sin(x) + x + y)\n",
      " |      \n",
      " |      -- self is a Mul\n",
      " |      \n",
      " |      >>> (x*sin(x)*cos(y)).as_independent(x)\n",
      " |      (cos(y), x*sin(x))\n",
      " |      \n",
      " |      non-commutative terms cannot always be separated out when self is a Mul\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)\n",
      " |      >>> (n1 + n1*n2).as_independent(n2)\n",
      " |      (n1, n1*n2)\n",
      " |      >>> (n2*n1 + n1*n2).as_independent(n2)\n",
      " |      (0, n1*n2 + n2*n1)\n",
      " |      >>> (n1*n2*n3).as_independent(n1)\n",
      " |      (1, n1*n2*n3)\n",
      " |      >>> (n1*n2*n3).as_independent(n2)\n",
      " |      (n1, n2*n3)\n",
      " |      >>> ((x-n1)*(x-y)).as_independent(x)\n",
      " |      (1, (x - y)*(x - n1))\n",
      " |      \n",
      " |      -- self is anything else:\n",
      " |      \n",
      " |      >>> (sin(x)).as_independent(x)\n",
      " |      (1, sin(x))\n",
      " |      >>> (sin(x)).as_independent(y)\n",
      " |      (sin(x), 1)\n",
      " |      >>> exp(x+y).as_independent(x)\n",
      " |      (1, exp(x + y))\n",
      " |      \n",
      " |      -- force self to be treated as an Add:\n",
      " |      \n",
      " |      >>> (3*x).as_independent(x, as_Add=True)\n",
      " |      (0, 3*x)\n",
      " |      \n",
      " |      -- force self to be treated as a Mul:\n",
      " |      \n",
      " |      >>> (3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x + 3)\n",
      " |      >>> (-3+x).as_independent(x, as_Add=False)\n",
      " |      (1, x - 3)\n",
      " |      \n",
      " |      Note how the below differs from the above in making the\n",
      " |      constant on the dep term positive.\n",
      " |      \n",
      " |      >>> (y*(-3+x)).as_independent(x)\n",
      " |      (y, x - 3)\n",
      " |      \n",
      " |      -- use .as_independent() for true independence testing instead\n",
      " |         of .has(). The former considers only symbols in the free\n",
      " |         symbols while the latter considers all symbols\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> I = Integral(x, (x, 1, 2))\n",
      " |      >>> I.has(x)\n",
      " |      True\n",
      " |      >>> x in I.free_symbols\n",
      " |      False\n",
      " |      >>> I.as_independent(x) == (I, 1)\n",
      " |      True\n",
      " |      >>> (I + x).as_independent(x) == (I, x)\n",
      " |      True\n",
      " |      \n",
      " |      Note: when trying to get independent terms, a separation method\n",
      " |      might need to be used first. In this case, it is important to keep\n",
      " |      track of what you send to this routine so you know how to interpret\n",
      " |      the returned values\n",
      " |      \n",
      " |      >>> from sympy import separatevars, log\n",
      " |      >>> separatevars(exp(x+y)).as_independent(x)\n",
      " |      (exp(y), exp(x))\n",
      " |      >>> (x + x*y).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> separatevars(x + x*y).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).as_independent(y)\n",
      " |      (x, y + 1)\n",
      " |      >>> (x*(1 + y)).expand(mul=True).as_independent(y)\n",
      " |      (x, x*y)\n",
      " |      >>> a, b=symbols('a b', positive=True)\n",
      " |      >>> (log(a*b).expand(log=True)).as_independent(b)\n",
      " |      (log(a), log(b))\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      separatevars\n",
      " |      expand_log\n",
      " |      sympy.core.add.Add.as_two_terms\n",
      " |      sympy.core.mul.Mul.as_two_terms\n",
      " |      as_coeff_mul\n",
      " |  \n",
      " |  as_leading_term(self, *symbols, logx=None, cdir=0)\n",
      " |      Returns the leading (nonzero) term of the series expansion of self.\n",
      " |      \n",
      " |      The _eval_as_leading_term routines are used to do this, and they must\n",
      " |      always return a non-zero value.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + x**2).as_leading_term(x)\n",
      " |      1\n",
      " |      >>> (1/x**2 + x + x**2).as_leading_term(x)\n",
      " |      x**(-2)\n",
      " |  \n",
      " |  as_ordered_factors(self, order=None)\n",
      " |      Return list of ordered factors (if Mul) else [self].\n",
      " |  \n",
      " |  as_ordered_terms(self, order=None, data=False)\n",
      " |      Transform an expression to an ordered list of terms.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, cos\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()\n",
      " |      [sin(x)**2*cos(x), sin(x)**2, 1]\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  as_powers_dict(self)\n",
      " |      Return self as a dictionary of factors with each factor being\n",
      " |      treated as a power. The keys are the bases of the factors and the\n",
      " |      values, the corresponding exponents. The resulting dictionary should\n",
      " |      be used with caution if the expression is a Mul and contains non-\n",
      " |      commutative factors since the order that they appeared will be lost in\n",
      " |      the dictionary.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      as_ordered_factors: An alternative for noncommutative applications,\n",
      " |                          returning an ordered list of factors.\n",
      " |      args_cnc: Similar to as_ordered_factors, but guarantees separation\n",
      " |                of commutative and noncommutative factors.\n",
      " |  \n",
      " |  as_real_imag(self, deep=True, **hints)\n",
      " |      Performs complex expansion on 'self' and returns a tuple\n",
      " |      containing collected both real and imaginary parts. This\n",
      " |      method cannot be confused with re() and im() functions,\n",
      " |      which does not perform complex expansion at evaluation.\n",
      " |      \n",
      " |      However it is possible to expand both re() and im()\n",
      " |      functions and get exactly the same results as with\n",
      " |      a single call to this function.\n",
      " |      \n",
      " |      >>> from sympy import symbols, I\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> (x + y*I).as_real_imag()\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> from sympy.abc import z, w\n",
      " |      \n",
      " |      >>> (z + w*I).as_real_imag()\n",
      " |      (re(z) - im(w), re(w) + im(z))\n",
      " |  \n",
      " |  as_terms(self)\n",
      " |      Transform an expression to a list of terms.\n",
      " |  \n",
      " |  aseries(self, x=None, n=6, bound=0, hir=False)\n",
      " |      Asymptotic Series expansion of self.\n",
      " |      This is equivalent to ``self.series(x, oo, n)``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      self : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      hir : Boolean\n",
      " |            Set this parameter to be True to produce hierarchical series.\n",
      " |            It stops the recursion at an early level and may provide nicer\n",
      " |            and more useful results.\n",
      " |      \n",
      " |      bound : Value, Integer\n",
      " |              Use the ``bound`` parameter to give limit on rewriting\n",
      " |              coefficients in its normalised form.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, exp\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> e = sin(1/x + exp(-x)) - sin(1/x)\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)\n",
      " |      \n",
      " |      >>> e.aseries(x, n=3, hir=True)\n",
      " |      -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))\n",
      " |      \n",
      " |      >>> e = exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x)\n",
      " |      exp(exp(x)/(1 - 1/x))\n",
      " |      \n",
      " |      >>> e.aseries(x, bound=3) # doctest: +SKIP\n",
      " |      exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).aseries(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr\n",
      " |          Asymptotic series expansion of the expression.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This algorithm is directly induced from the limit computational algorithm provided by Gruntz.\n",
      " |      It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first\n",
      " |      to look for the most rapidly varying subexpression w of a given expression f and then expands f\n",
      " |      in a series in w. Then same thing is recursively done on the leading coefficient\n",
      " |      till we get constant coefficients.\n",
      " |      \n",
      " |      If the most rapidly varying subexpression of a given expression f is f itself,\n",
      " |      the algorithm tries to find a normalised representation of the mrv set and rewrites f\n",
      " |      using this normalised representation.\n",
      " |      \n",
      " |      If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``\n",
      " |      where ``w`` belongs to the most rapidly varying expression of ``self``.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.\n",
      " |             In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.\n",
      " |             pp. 239-244.\n",
      " |      .. [2] Gruntz thesis - p90\n",
      " |      .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      Expr.aseries: See the docstring of this function for complete details of this wrapper.\n",
      " |  \n",
      " |  cancel(self, *gens, **args)\n",
      " |      See the cancel function in sympy.polys\n",
      " |  \n",
      " |  coeff(self, x, n=1, right=False, _first=True)\n",
      " |      Returns the coefficient from the term(s) containing ``x**n``. If ``n``\n",
      " |      is zero then all terms independent of ``x`` will be returned.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      When ``x`` is noncommutative, the coefficient to the left (default) or\n",
      " |      right of ``x`` can be returned. The keyword 'right' is ignored when\n",
      " |      ``x`` is commutative.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      You can select terms that have an explicit negative in front of them:\n",
      " |      \n",
      " |      >>> (-x + 2*y).coeff(-1)\n",
      " |      x\n",
      " |      >>> (x - 2*y).coeff(-1)\n",
      " |      2*y\n",
      " |      \n",
      " |      You can select terms with no Rational coefficient:\n",
      " |      \n",
      " |      >>> (x + 2*y).coeff(1)\n",
      " |      x\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(1)\n",
      " |      0\n",
      " |      \n",
      " |      You can select terms independent of x by making n=0; in this case\n",
      " |      expr.as_independent(x)[0] is returned (and 0 will be returned instead\n",
      " |      of None):\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x, 0)\n",
      " |      3\n",
      " |      >>> eq = ((x + 1)**3).expand() + 1\n",
      " |      >>> eq\n",
      " |      x**3 + 3*x**2 + 3*x + 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 2]\n",
      " |      >>> eq -= 2\n",
      " |      >>> [eq.coeff(x, i) for i in reversed(range(4))]\n",
      " |      [1, 3, 3, 0]\n",
      " |      \n",
      " |      You can select terms that have a numerical term in front of them:\n",
      " |      \n",
      " |      >>> (-x - 2*y).coeff(2)\n",
      " |      -y\n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> (x + sqrt(2)*x).coeff(sqrt(2))\n",
      " |      x\n",
      " |      \n",
      " |      The matching is exact:\n",
      " |      \n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x)\n",
      " |      2\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**2)\n",
      " |      4\n",
      " |      >>> (3 + 2*x + 4*x**2).coeff(x**3)\n",
      " |      0\n",
      " |      >>> (z*(x + y)**2).coeff((x + y)**2)\n",
      " |      z\n",
      " |      >>> (z*(x + y)**2).coeff(x + y)\n",
      " |      0\n",
      " |      \n",
      " |      In addition, no factoring is done, so 1 + z*(1 + y) is not obtained\n",
      " |      from the following:\n",
      " |      \n",
      " |      >>> (x + z*(x + x*y)).coeff(x)\n",
      " |      1\n",
      " |      \n",
      " |      If such factoring is desired, factor_terms can be used first:\n",
      " |      \n",
      " |      >>> from sympy import factor_terms\n",
      " |      >>> factor_terms(x + z*(x + x*y)).coeff(x)\n",
      " |      z*(y + 1) + 1\n",
      " |      \n",
      " |      >>> n, m, o = symbols('n m o', commutative=False)\n",
      " |      >>> n.coeff(n)\n",
      " |      1\n",
      " |      >>> (3*n).coeff(n)\n",
      " |      3\n",
      " |      >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m\n",
      " |      1 + m\n",
      " |      >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m\n",
      " |      m\n",
      " |      \n",
      " |      If there is more than one possible coefficient 0 is returned:\n",
      " |      \n",
      " |      >>> (n*m + m*n).coeff(n)\n",
      " |      0\n",
      " |      \n",
      " |      If there is only one possible coefficient, it is returned:\n",
      " |      \n",
      " |      >>> (n*m + x*m*n).coeff(m*n)\n",
      " |      x\n",
      " |      >>> (n*m + x*m*n).coeff(m*n, right=1)\n",
      " |      1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_coefficient: separate the expression into a coefficient and factor\n",
      " |      as_coeff_Add: separate the additive constant from an expression\n",
      " |      as_coeff_Mul: separate the multiplicative constant from an expression\n",
      " |      as_independent: separate x-dependent terms/factors from others\n",
      " |      sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly\n",
      " |      sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used\n",
      " |  \n",
      " |  collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True)\n",
      " |      See the collect function in sympy.simplify\n",
      " |  \n",
      " |  combsimp(self)\n",
      " |      See the combsimp function in sympy.simplify\n",
      " |  \n",
      " |  compute_leading_term(self, x, logx=None)\n",
      " |      Deprecated function to compute the leading term of a series.\n",
      " |      \n",
      " |      as_leading_term is only allowed for results of .series()\n",
      " |      This is a wrapper to compute a series first.\n",
      " |  \n",
      " |  conjugate(self)\n",
      " |      Returns the complex conjugate of 'self'.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      Wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  diff(self, *symbols, **assumptions)\n",
      " |  \n",
      " |  dir(self, x, cdir)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if self == other, False if it does not, or None. If\n",
      " |      failing_expression is True then the expression which did not simplify\n",
      " |      to a 0 will be returned instead of None.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      If ``self`` is a Number (or complex number) that is not zero, then\n",
      " |      the result is False.\n",
      " |      \n",
      " |      If ``self`` is a number and has not evaluated to zero, evalf will be\n",
      " |      used to test whether the expression evaluates to zero. If it does so\n",
      " |      and the result has significance (i.e. the precision is either -1, for\n",
      " |      a Rational result, or is greater than 1) then the evalf value will be\n",
      " |      used to return True or False.\n",
      " |  \n",
      " |  expand(self, deep=True, modulus=None, power_base=True, power_exp=True, mul=True, log=True, multinomial=True, basic=True, **hints)\n",
      " |      Expand an expression using hints.\n",
      " |      \n",
      " |      See the docstring of the expand() function in sympy.core.function for\n",
      " |      more information.\n",
      " |  \n",
      " |  extract_additively(self, c)\n",
      " |      Return self - c if it's possible to subtract c from self and\n",
      " |      make all matching coefficients move towards zero, else return None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> e = 2*x + 3\n",
      " |      >>> e.extract_additively(x + 1)\n",
      " |      x + 2\n",
      " |      >>> e.extract_additively(3*x)\n",
      " |      >>> e.extract_additively(4)\n",
      " |      >>> (y*(x + 1)).extract_additively(x + 1)\n",
      " |      >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)\n",
      " |      (x + 1)*(x + 2*y) + 3\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      extract_multiplicatively\n",
      " |      coeff\n",
      " |      as_coefficient\n",
      " |  \n",
      " |  extract_branch_factor(self, allow_half=False)\n",
      " |      Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.\n",
      " |      Return (z, n).\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, I, pi\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> exp_polar(I*pi).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), 0)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor()\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(-pi*I).extract_branch_factor()\n",
      " |      (exp_polar(I*pi), -1)\n",
      " |      >>> exp_polar(3*pi*I + x).extract_branch_factor()\n",
      " |      (exp_polar(x + I*pi), 1)\n",
      " |      >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()\n",
      " |      (y*exp_polar(2*pi*x), -1)\n",
      " |      >>> exp_polar(-I*pi/2).extract_branch_factor()\n",
      " |      (exp_polar(-I*pi/2), 0)\n",
      " |      \n",
      " |      If allow_half is True, also extract exp_polar(I*pi):\n",
      " |      \n",
      " |      >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1/2)\n",
      " |      >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 1)\n",
      " |      >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, 3/2)\n",
      " |      >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)\n",
      " |      (1, -1/2)\n",
      " |  \n",
      " |  extract_multiplicatively(self, c)\n",
      " |      Return None if it's not possible to make self in the form\n",
      " |      c * something in a nice way, i.e. preserving the properties\n",
      " |      of arguments of self.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Rational\n",
      " |      \n",
      " |      >>> x, y = symbols('x,y', real=True)\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**2 * y)\n",
      " |      x*y**2\n",
      " |      \n",
      " |      >>> ((x*y)**3).extract_multiplicatively(x**4 * y)\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(2)\n",
      " |      x\n",
      " |      \n",
      " |      >>> (2*x).extract_multiplicatively(3)\n",
      " |      \n",
      " |      >>> (Rational(1, 2)*x).extract_multiplicatively(3)\n",
      " |      x/6\n",
      " |  \n",
      " |  factor(self, *gens, **args)\n",
      " |      See the factor() function in sympy.polys.polytools\n",
      " |  \n",
      " |  fourier_series(self, limits=None)\n",
      " |      Compute fourier sine/cosine series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fourier_series` in sympy.series.fourier\n",
      " |      for more information.\n",
      " |  \n",
      " |  fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True, full=False)\n",
      " |      Compute formal power power series of self.\n",
      " |      \n",
      " |      See the docstring of the :func:`fps` function in sympy.series.formal for\n",
      " |      more information.\n",
      " |  \n",
      " |  gammasimp(self)\n",
      " |      See the gammasimp function in sympy.simplify\n",
      " |  \n",
      " |  getO(self)\n",
      " |      Returns the additive O(..) symbol if there is one, else None.\n",
      " |  \n",
      " |  getn(self)\n",
      " |      Returns the order of the expression.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      The order is determined either from the O(...) term. If there\n",
      " |      is no O(...) term, it returns None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import O\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1 + x + O(x**2)).getn()\n",
      " |      2\n",
      " |      >>> (1 + x).getn()\n",
      " |  \n",
      " |  integrate(self, *args, **kwargs)\n",
      " |      See the integrate function in sympy.integrals\n",
      " |  \n",
      " |  is_algebraic_expr(self, *syms)\n",
      " |      This tests whether a given expression is algebraic or not, in the\n",
      " |      given symbols, syms. When syms is not given, all free symbols\n",
      " |      will be used. The rational function does not have to be in expanded\n",
      " |      or in any kind of canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"algebraic\n",
      " |      expressions\" with symbolic exponents. This is a simple extension to the\n",
      " |      is_rational_function, including rational exponentiation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sqrt\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> sqrt(1 + x).is_rational_function()\n",
      " |      False\n",
      " |      >>> sqrt(1 + x).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be an algebraic\n",
      " |      expression to become one.\n",
      " |      \n",
      " |      >>> from sympy import exp, factor\n",
      " |      >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)\n",
      " |      >>> a.is_algebraic_expr(x)\n",
      " |      False\n",
      " |      >>> factor(a).is_algebraic_expr()\n",
      " |      True\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      is_rational_function\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Algebraic_expression\n",
      " |  \n",
      " |  is_meromorphic(self, x, a)\n",
      " |      This tests whether an expression is meromorphic as\n",
      " |      a function of the given symbol ``x`` at the point ``a``.\n",
      " |      \n",
      " |      This method is intended as a quick test that will return\n",
      " |      None if no decision can be made without simplification or\n",
      " |      more detailed analysis.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import zoo, log, sin, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 1/x**2 + 1 - 2*x**3\n",
      " |      >>> f.is_meromorphic(x, 0)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> f.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      >>> g = x**log(3)\n",
      " |      >>> g.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> g.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> g.is_meromorphic(x, zoo)\n",
      " |      False\n",
      " |      \n",
      " |      >>> h = sin(1/x)*x**2\n",
      " |      >>> h.is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> h.is_meromorphic(x, 1)\n",
      " |      True\n",
      " |      >>> h.is_meromorphic(x, zoo)\n",
      " |      True\n",
      " |      \n",
      " |      Multivalued functions are considered meromorphic when their\n",
      " |      branches are meromorphic. Thus most functions are meromorphic\n",
      " |      everywhere except at essential singularities and branch points.\n",
      " |      In particular, they will be meromorphic also on branch cuts\n",
      " |      except at their endpoints.\n",
      " |      \n",
      " |      >>> log(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> log(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |      >>> sqrt(x).is_meromorphic(x, -1)\n",
      " |      True\n",
      " |      >>> sqrt(x).is_meromorphic(x, 0)\n",
      " |      False\n",
      " |  \n",
      " |  is_polynomial(self, *syms)\n",
      " |      Return True if self is a polynomial in syms and False otherwise.\n",
      " |      \n",
      " |      This checks if self is an exact polynomial in syms.  This function\n",
      " |      returns False for expressions that are \"polynomials\" with symbolic\n",
      " |      exponents.  Thus, you should be able to apply polynomial algorithms to\n",
      " |      expressions for which this returns True, and Poly(expr, \\*syms) should\n",
      " |      work if and only if expr.is_polynomial(\\*syms) returns True. The\n",
      " |      polynomial does not have to be in expanded form.  If no symbols are\n",
      " |      given, all free symbols in the expression will be used.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', polynomial=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Function\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial(x)\n",
      " |      True\n",
      " |      >>> ((x**2 + 1)**4).is_polynomial()\n",
      " |      True\n",
      " |      >>> (2**x + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (2**x + 1).is_polynomial(2**x)\n",
      " |      True\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (f(x) + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      >>> (f(x) + 1).is_polynomial(f(x))\n",
      " |      True\n",
      " |      >>> (1/f(x) + 1).is_polynomial(f(x))\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', nonnegative=True, integer=True)\n",
      " |      >>> (x**n + 1).is_polynomial(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a polynomial to\n",
      " |      become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor, cancel\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)\n",
      " |      >>> a.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      y + 1\n",
      " |      >>> factor(a).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      >>> b = (y**2 + 2*y + 1)/(y + 1)\n",
      " |      >>> b.is_polynomial(y)\n",
      " |      False\n",
      " |      >>> cancel(b)\n",
      " |      y + 1\n",
      " |      >>> cancel(b).is_polynomial(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also .is_rational_function()\n",
      " |  \n",
      " |  is_rational_function(self, *syms)\n",
      " |      Test whether function is a ratio of two polynomials in the given\n",
      " |      symbols, syms. When syms is not given, all free symbols will be used.\n",
      " |      The rational function does not have to be in expanded or in any kind of\n",
      " |      canonical form.\n",
      " |      \n",
      " |      This function returns False for expressions that are \"rational\n",
      " |      functions\" with symbolic exponents.  Thus, you should be able to call\n",
      " |      .as_numer_denom() and apply polynomial algorithms to the result for\n",
      " |      expressions for which this returns True.\n",
      " |      \n",
      " |      This is not part of the assumptions system.  You cannot do\n",
      " |      Symbol('z', rational_function=True).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> (x/y).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x**2).is_rational_function()\n",
      " |      True\n",
      " |      \n",
      " |      >>> (x/sin(y)).is_rational_function(y)\n",
      " |      False\n",
      " |      \n",
      " |      >>> n = Symbol('n', integer=True)\n",
      " |      >>> (x**n + 1).is_rational_function(x)\n",
      " |      False\n",
      " |      \n",
      " |      This function does not attempt any nontrivial simplifications that may\n",
      " |      result in an expression that does not appear to be a rational function\n",
      " |      to become one.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, factor\n",
      " |      >>> y = Symbol('y', positive=True)\n",
      " |      >>> a = sqrt(y**2 + 2*y + 1)/y\n",
      " |      >>> a.is_rational_function(y)\n",
      " |      False\n",
      " |      >>> factor(a)\n",
      " |      (y + 1)/y\n",
      " |      >>> factor(a).is_rational_function(y)\n",
      " |      True\n",
      " |      \n",
      " |      See also is_algebraic_expr().\n",
      " |  \n",
      " |  leadterm(self, x, logx=None, cdir=0)\n",
      " |      Returns the leading term a*x**b as a tuple (a, b).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (1+x+x**2).leadterm(x)\n",
      " |      (1, 0)\n",
      " |      >>> (1/x**2+x+x**2).leadterm(x)\n",
      " |      (1, -2)\n",
      " |  \n",
      " |  limit(self, x, xlim, dir='+')\n",
      " |      Compute limit x->xlim.\n",
      " |  \n",
      " |  lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper for series yielding an iterator of the terms of the series.\n",
      " |      \n",
      " |      Note: an infinite series will yield an infinite iterator. The following,\n",
      " |      for exaxmple, will never terminate. It will just keep printing terms\n",
      " |      of the sin(x) series::\n",
      " |      \n",
      " |        for term in sin(x).lseries(x):\n",
      " |            print term\n",
      " |      \n",
      " |      The advantage of lseries() over nseries() is that many times you are\n",
      " |      just interested in the next term in the series (i.e. the first term for\n",
      " |      example), but you do not know how many you should ask for in nseries()\n",
      " |      using the \"n\" parameter.\n",
      " |      \n",
      " |      See also nseries().\n",
      " |  \n",
      " |  normal(self)\n",
      " |      Return the expression as a fraction.\n",
      " |      \n",
      " |      expression -> a/b\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      as_numer_denom: return ``(a, b)`` instead of ``a/b``\n",
      " |  \n",
      " |  nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Wrapper to _eval_nseries if assumptions allow, else to series.\n",
      " |      \n",
      " |      If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is\n",
      " |      called. This calculates \"n\" terms in the innermost expressions and\n",
      " |      then builds up the final series just by \"cross-multiplying\" everything\n",
      " |      out.\n",
      " |      \n",
      " |      The optional ``logx`` parameter can be used to replace any log(x) in the\n",
      " |      returned series with a symbolic value to avoid evaluating log(x) at 0. A\n",
      " |      symbol to use in place of log(x) should be provided.\n",
      " |      \n",
      " |      Advantage -- it's fast, because we do not have to determine how many\n",
      " |      terms we need to calculate in advance.\n",
      " |      \n",
      " |      Disadvantage -- you may end up with less terms than you may have\n",
      " |      expected, but the O(x**n) term appended will always be correct and\n",
      " |      so the result, though perhaps shorter, will also be correct.\n",
      " |      \n",
      " |      If any of those assumptions is not met, this is treated like a\n",
      " |      wrapper to series which will try harder to return the correct\n",
      " |      number of terms.\n",
      " |      \n",
      " |      See also lseries().\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin, log, Symbol\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> sin(x).nseries(x, 0, 6)\n",
      " |      x - x**3/6 + x**5/120 + O(x**6)\n",
      " |      >>> log(x+1).nseries(x, 0, 5)\n",
      " |      x - x**2/2 + x**3/3 - x**4/4 + O(x**5)\n",
      " |      \n",
      " |      Handling of the ``logx`` parameter --- in the following example the\n",
      " |      expansion fails since ``sin`` does not have an asymptotic expansion\n",
      " |      at -oo (the limit of log(x) as x approaches 0):\n",
      " |      \n",
      " |      >>> e = sin(log(x))\n",
      " |      >>> e.nseries(x, 0, 6)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PoleError: ...\n",
      " |      ...\n",
      " |      >>> logx = Symbol('logx')\n",
      " |      >>> e.nseries(x, 0, 6, logx=logx)\n",
      " |      sin(logx)\n",
      " |      \n",
      " |      In the following example, the expansion works but only returns self\n",
      " |      unless the ``logx`` parameter is used:\n",
      " |      \n",
      " |      >>> e = x**y\n",
      " |      >>> e.nseries(x, 0, 2)\n",
      " |      x**y\n",
      " |      >>> e.nseries(x, 0, 2, logx=logx)\n",
      " |      exp(logx*y)\n",
      " |  \n",
      " |  nsimplify(self, constants=(), tolerance=None, full=False)\n",
      " |      See the nsimplify function in sympy.simplify\n",
      " |  \n",
      " |  powsimp(self, *args, **kwargs)\n",
      " |      See the powsimp function in sympy.simplify\n",
      " |  \n",
      " |  primitive(self)\n",
      " |      Return the positive Rational that can be extracted non-recursively\n",
      " |      from every term of self (i.e., self is treated like an Add). This is\n",
      " |      like the as_coeff_Mul() method but primitive always extracts a positive\n",
      " |      Rational (never a negative or a Float).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (3*(x + 1)**2).primitive()\n",
      " |      (3, (x + 1)**2)\n",
      " |      >>> a = (6*x + 2); a.primitive()\n",
      " |      (2, 3*x + 1)\n",
      " |      >>> b = (x/2 + 3); b.primitive()\n",
      " |      (1/2, x + 6)\n",
      " |      >>> (a*b).primitive() == (1, a*b)\n",
      " |      True\n",
      " |  \n",
      " |  radsimp(self, **kwargs)\n",
      " |      See the radsimp function in sympy.simplify\n",
      " |  \n",
      " |  ratsimp(self)\n",
      " |      See the ratsimp function in sympy.simplify\n",
      " |  \n",
      " |  removeO(self)\n",
      " |      Removes the additive O(..) symbol if there is one\n",
      " |  \n",
      " |  round(self, n=None)\n",
      " |      Return x rounded to the given decimal place.\n",
      " |      \n",
      " |      If a complex number would results, apply round to the real\n",
      " |      and imaginary components of the number.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, E, I, S, Number\n",
      " |      >>> pi.round()\n",
      " |      3\n",
      " |      >>> pi.round(2)\n",
      " |      3.14\n",
      " |      >>> (2*pi + E*I).round()\n",
      " |      6 + 3*I\n",
      " |      \n",
      " |      The round method has a chopping effect:\n",
      " |      \n",
      " |      >>> (2*pi + I/10).round()\n",
      " |      6\n",
      " |      >>> (pi/10 + 2*I).round()\n",
      " |      2*I\n",
      " |      >>> (pi/10 + E*I).round(2)\n",
      " |      0.31 + 2.72*I\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      The Python ``round`` function uses the SymPy ``round`` method so it\n",
      " |      will always return a SymPy number (not a Python float or int):\n",
      " |      \n",
      " |      >>> isinstance(round(S(123), -2), Number)\n",
      " |      True\n",
      " |  \n",
      " |  separate(self, deep=False, force=False)\n",
      " |      See the separate function in sympy.simplify\n",
      " |  \n",
      " |  series(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0)\n",
      " |      Series expansion of \"self\" around ``x = x0`` yielding either terms of\n",
      " |      the series one by one (the lazy series given when n=None), else\n",
      " |      all the terms at once when n != None.\n",
      " |      \n",
      " |      Returns the series expansion of \"self\" around the point ``x = x0``\n",
      " |      with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).\n",
      " |      \n",
      " |      If ``x=None`` and ``self`` is univariate, the univariate symbol will\n",
      " |      be supplied, otherwise an error will be raised.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      expr : Expression\n",
      " |             The expression whose series is to be expanded.\n",
      " |      \n",
      " |      x : Symbol\n",
      " |          It is the variable of the expression to be calculated.\n",
      " |      \n",
      " |      x0 : Value\n",
      " |           The value around which ``x`` is calculated. Can be any value\n",
      " |           from ``-oo`` to ``oo``.\n",
      " |      \n",
      " |      n : Value\n",
      " |          The value used to represent the order in terms of ``x**n``,\n",
      " |          up to which the series is to be expanded.\n",
      " |      \n",
      " |      dir : String, optional\n",
      " |            The series-expansion can be bi-directional. If ``dir=\"+\"``,\n",
      " |            then (x->x0+). If ``dir=\"-\", then (x->x0-). For infinite\n",
      " |            ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined\n",
      " |            from the direction of the infinity (i.e., ``dir=\"-\"`` for\n",
      " |            ``oo``).\n",
      " |      \n",
      " |      logx : optional\n",
      " |             It is used to replace any log(x) in the returned series with a\n",
      " |             symbolic value rather than evaluating the actual value.\n",
      " |      \n",
      " |      cdir : optional\n",
      " |             It stands for complex direction, and indicates the direction\n",
      " |             from which the expansion needs to be evaluated.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cos, exp, tan\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> cos(x).series()\n",
      " |      1 - x**2/2 + x**4/24 + O(x**6)\n",
      " |      >>> cos(x).series(n=4)\n",
      " |      1 - x**2/2 + O(x**4)\n",
      " |      >>> cos(x).series(x, x0=1, n=2)\n",
      " |      cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))\n",
      " |      >>> e = cos(x + exp(y))\n",
      " |      >>> e.series(y, n=2)\n",
      " |      cos(x + 1) - y*sin(x + 1) + O(y**2)\n",
      " |      >>> e.series(x, n=2)\n",
      " |      cos(exp(y)) - x*sin(exp(y)) + O(x**2)\n",
      " |      \n",
      " |      If ``n=None`` then a generator of the series terms will be returned.\n",
      " |      \n",
      " |      >>> term=cos(x).series(n=None)\n",
      " |      >>> [next(term) for i in range(2)]\n",
      " |      [1, -x**2/2]\n",
      " |      \n",
      " |      For ``dir=+`` (default) the series is calculated from the right and\n",
      " |      for ``dir=-`` the series from the left. For smooth functions this\n",
      " |      flag will not alter the results.\n",
      " |      \n",
      " |      >>> abs(x).series(dir=\"+\")\n",
      " |      x\n",
      " |      >>> abs(x).series(dir=\"-\")\n",
      " |      -x\n",
      " |      >>> f = tan(x)\n",
      " |      >>> f.series(x, 2, 6, \"+\")\n",
      " |      tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +\n",
      " |      (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +\n",
      " |      5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +\n",
      " |      2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))\n",
      " |      \n",
      " |      >>> f.series(x, 2, 3, \"-\")\n",
      " |      tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))\n",
      " |      + O((x - 2)**3, (x, 2))\n",
      " |      \n",
      " |      For rational expressions this method may return original expression without the Order term.\n",
      " |      >>> (1/x).series(x, n=8)\n",
      " |      1/x\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      Expr : Expression\n",
      " |          Series expansion of the expression about x0\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      TypeError\n",
      " |          If \"n\" and \"x0\" are infinity objects\n",
      " |      \n",
      " |      PoleError\n",
      " |          If \"x0\" is an infinity object\n",
      " |  \n",
      " |  taylor_term(self, n, x, *previous_terms)\n",
      " |      General method for the taylor term.\n",
      " |      \n",
      " |      This method is slow, because it differentiates n-times. Subclasses can\n",
      " |      redefine it to make it faster by using the \"previous_terms\".\n",
      " |  \n",
      " |  together(self, *args, **kwargs)\n",
      " |      See the together function in sympy.polys\n",
      " |  \n",
      " |  transpose(self)\n",
      " |  \n",
      " |  trigsimp(self, **args)\n",
      " |      See the trigsimp function in sympy.simplify\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.expr.Expr:\n",
      " |  \n",
      " |  is_scalar = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      Return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  has_xfree(self, s: 'set[Basic]')\n",
      " |      Return True if self has any of the patterns in s as a\n",
      " |      free argument, else False. This is like `Basic.has_free`\n",
      " |      but this will only report exact argument matches.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> f(x).has_xfree({f})\n",
      " |      False\n",
      " |      >>> f(x).has_xfree({f(x)})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x})\n",
      " |      True\n",
      " |      >>> f(x + 1).has_xfree({x + 1})\n",
      " |      True\n",
      " |      >>> f(x + y + 1).has_xfree({x + 1})\n",
      " |      False\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : Expr\n",
      " |          A *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __init_subclass__() from builtins.type\n",
      " |      This method is called when a class is subclassed.\n",
      " |      \n",
      " |      The default implementation does nothing. It may be\n",
      " |      overridden to extend subclasses.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from builtins.type\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(S(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class Cube:\n",
    "    def __init__(self,name:str, length: Number) -> None:\n",
    "        symbol_list = []\n",
    "        symbol_list_1 = []\n",
    "        if match(\"^[a-zA-Z]{4}\", name):\n",
    "            pass\n",
    "        else:\n",
    "            name = \"ABCD\"\n",
    "\n",
    "        for i in range(4):\n",
    "            symbol_list.append(symbols(name[i]))\n",
    "            symbol_list_1.append(symbols(name[i] + str(1)))\n",
    "\n",
    "        self.points = [\n",
    "            Point(0, 0, 0),\n",
    "            Point(length, 0, 0),\n",
    "            Point(0, length, 0),\n",
    "            Point(length, length, 0),\n",
    "            Point(0, 0, length),\n",
    "            Point(length, 0, length),\n",
    "            Point(0, length, length),\n",
    "            Point(length, length, length),\n",
    "        ]\n",
    "\n",
    "        self.point_symbols = [*symbol_list, *symbol_list_1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cube=Cube(\"ABCD\",1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(8):\n",
    "    cube.point_symbols[i]=cube.points[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B,C,D,A1,B1,C1,D1=cube.points"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, 0, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(0, 0, 0)"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(D+D1)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(1, 1, \\frac{1}{2}\\right)$"
      ],
      "text/plain": [
       "Point3D(1, 1, 1/2)"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p=Plane(A,B1,E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C1.distance(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "hyper=Hyperbola(Point(0,0),sqrt(3),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k =symbols(\"k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import x,y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=intersection(l,hyper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\sqrt{3} k \\sqrt{k^{2} + 1}}{3 k^{2} - 1}$"
      ],
      "text/plain": [
       "2*sqrt(3)*k*sqrt(k**2 + 1)/(3*k**2 - 1)"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.y-B.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=Line(x-t*y-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 t y + y^{2} \\left(t^{2} - 3\\right) + 1$"
      ],
      "text/plain": [
       "4*t*y + y**2*(t**2 - 3) + 1"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(m,hyper,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Circle(x**2+y**2-a*x+(3*a-1)*y+Rational(5,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 10 a^{2} - 6 a - 4$"
      ],
      "text/plain": [
       "10*a**2 - 6*a - 4"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand((c.radius)**2*4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, - \\frac{2}{5}\\right) \\cup \\left(1, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, -2/5), Interval.open(1, oo))"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((c.radius)**2>0,a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{5}{21}$"
      ],
      "text/plain": [
       "5/21"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binomial(13,4)*binomial(9,4)/(binomial(15,10)*binomial(10,5))*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - k x + 2 k + y$"
      ],
      "text/plain": [
       "-k*x + 2*k + y"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=Ellipse(Point(0,0),Rational(1,2),1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 x^{2} + y^{2} - 1$"
      ],
      "text/plain": [
       "4*x**2 + y**2 - 1"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 k^{2} x + 4 k^{2} + x^{2} \\left(k^{2} + 4\\right) - 1$"
      ],
      "text/plain": [
       "-4*k**2*x + 4*k**2 + x**2*(k**2 + 4) - 1"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 15 k^{2} + 16 k y + y^{2} \\left(k^{2} + 4\\right)$"
      ],
      "text/plain": [
       "15*k**2 + 16*k*y + y**2*(k**2 + 4)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,e,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{16}{19} - \\frac{4 \\sqrt{3} i}{19}, - \\frac{16}{19} + \\frac{4 \\sqrt{3} i}{19}\\right\\}$"
      ],
      "text/plain": [
       "{-16/19 - 4*sqrt(3)*I/19, -16/19 + 4*sqrt(3)*I/19}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_.subs(y,2),k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_,x=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 60 k^{4} + 16 k^{2}$"
      ],
      "text/plain": [
       "-60*k**4 + 16*k**2"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(q.delta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[- \\frac{2 \\sqrt{15}}{15}, \\frac{2 \\sqrt{15}}{15}\\right]$"
      ],
      "text/plain": [
       "Interval(-2*sqrt(15)/15, 2*sqrt(15)/15)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_>=0,k,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=Circle(Point(2,2),Point(1,3),Point(1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - 1\\right)^{2} + \\left(y - 2\\right)^{2} - 1$"
      ],
      "text/plain": [
       "(x - 1)**2 + (y - 2)**2 - 1"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(2,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(2,2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(0,2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(3,4,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, -1]"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(B-A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, -2]"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(D-A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 8, 2]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Data(B-A)*Data(D-A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix([B-A,C-A,D-A]).rank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(-2, 2, 0\\right)$"
      ],
      "text/plain": [
       "Point3D(-2, 2, 0)"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m,a=symbols(\"m,a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(x-m*y-a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "para=Parabola(Point(1,0),Line(x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 x - y^{2}$"
      ],
      "text/plain": [
       "4*x - y**2"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "para.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 a + 4 m y - y^{2}$"
      ],
      "text/plain": [
       "4*a + 4*m*y - y**2"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(l,para,y=y,first=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_,x=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1,y2=q.roots.args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 a \\sqrt{m^{2} + 1}$"
      ],
      "text/plain": [
       "-4*a*sqrt(m**2 + 1)"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(y1*y2)*sqrt(m**2+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 \\sqrt{a + m^{2}}$"
      ],
      "text/plain": [
       "-4*sqrt(a + m**2)"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(y1-y2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(a - 1\\right) \\left(a m^{2} + a + m^{2}\\right)$"
      ],
      "text/plain": [
       "(a - 1)*(a*m**2 + a + m**2)"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(a**2*(1+m**2)-(m**2+a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=Point(0,-sqrt(3),0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1=Point(0,-sqrt(3),2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B=Point(1,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E=(A+B)/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D=Point(-1,0,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "P=Point(0,sqrt(3),2*t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(0, \\sqrt{3}, 2 t\\right)$"
      ],
      "text/plain": [
       "Point3D(0, sqrt(3), 2*t)"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - 4 t$"
      ],
      "text/plain": [
       "1 - 4*t"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(Data(E-A1)*Data(P-B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4*t, -2*sqrt(3)]"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Data(Plane(B,D,P).normal_vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{16 t^{2} + 12}$"
      ],
      "text/plain": [
       "sqrt(16*t**2 + 12)"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(sum(Data(Plane(B,D,P).normal_vector)**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{5}$"
      ],
      "text/plain": [
       "sqrt(5)"
      ]
     },
     "execution_count": 263,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(sum(Data(E-A1)**2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 \\sqrt{3} t + 4 \\sqrt{3}$"
      ],
      "text/plain": [
       "2*sqrt(3)*t + 4*sqrt(3)"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(Data(Plane(B,D,P).normal_vector)*Data(E-A1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 84 t^{2} + 64 t - 11$"
      ],
      "text/plain": [
       "-84*t**2 + 64*t - 11"
      ]
     },
     "execution_count": 278,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(factor(simplify_equation(Eq(sum(Data(Plane(B,D,P).normal_vector)*Data(E-A1))/(sqrt(sum(Data(Plane(B,D,P).normal_vector)**2))*sqrt(sum(Data(E-A1)**2))),sqrt(15)/4),fraction=True,square=True,expr=True))/60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{11}{42}, \\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{11/42, 1/2}"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "solveset(sum(Data(Plane(B,D,P).normal_vector)*Data(E-A1))/(sqrt(sum(Data(Plane(B,D,P).normal_vector)**2))*sqrt(sum(Data(E-A1)**2)))-sqrt(15)/4,t,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(\\frac{1}{2}, \\frac{\\sqrt{3}}{2}, -2\\right)$"
      ],
      "text/plain": [
       "Point3D(1/2, sqrt(3)/2, -2)"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E-A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point3D}\\left(-1, \\sqrt{3}, 2 t\\right)$"
      ],
      "text/plain": [
       "Point3D(-1, sqrt(3), 2*t)"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{11}{42}, \\frac{1}{2}\\right\\}$"
      ],
      "text/plain": [
       "{11/42, 1/2}"
      ]
     },
     "execution_count": 280,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "QuadraticFunction(84,-64,11).roots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left|{a + i b - 1}\\right| + \\left|{a + i b + 1}\\right| - 4$"
      ],
      "text/plain": [
       "Abs(a + I*b - 1) + Abs(a + I*b + 1) - 4"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(abs(z-1)+abs(z+1)-4).subs(z,a+b*I)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,k=symbols(\"x,y,k\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=Ellipse(Point(0,0),2,sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{4} + \\frac{y^{2}}{3} - 1$"
      ],
      "text/plain": [
       "x**2/4 + y**2/3 - 1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.equation()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=Line(y-k*(x-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A,B=Intersection(l,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{- \\frac{6 k \\sqrt{k^{2} + 1}}{4 k^{2} + 3} + k - \\frac{3 k}{4 k^{2} + 3}}{k}, - \\frac{6 k \\sqrt{k^{2} + 1}}{4 k^{2} + 3} - \\frac{3 k}{4 k^{2} + 3}\\right)$"
      ],
      "text/plain": [
       "Point2D((-6*k*sqrt(k**2 + 1)/(4*k**2 + 3) + k - 3*k/(4*k**2 + 3))/k, -6*k*sqrt(k**2 + 1)/(4*k**2 + 3) - 3*k/(4*k**2 + 3))"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(\\frac{\\frac{6 k \\sqrt{k^{2} + 1}}{4 k^{2} + 3} + k - \\frac{3 k}{4 k^{2} + 3}}{k}, \\frac{6 k \\sqrt{k^{2} + 1}}{4 k^{2} + 3} - \\frac{3 k}{4 k^{2} + 3}\\right)$"
      ],
      "text/plain": [
       "Point2D((6*k*sqrt(k**2 + 1)/(4*k**2 + 3) + k - 3*k/(4*k**2 + 3))/k, 6*k*sqrt(k**2 + 1)/(4*k**2 + 3) - 3*k/(4*k**2 + 3))"
      ]
     },
     "execution_count": 292,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=Point(0,sqrt(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F=Point(1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{Point2D}\\left(1, - \\sqrt{3}\\right)$"
      ],
      "text/plain": [
       "Point2D(1, -sqrt(3))"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "((F-C))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Complex(p):\n",
    "    return p.x+p.y*I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "end=simplify(Complex(A-C)*Complex(B-C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{k^{2} - 8 \\sqrt{3} i k^{2} - 6 \\sqrt{3} k - 24 i k - 21}{4 k^{2} + 3}$"
      ],
      "text/plain": [
       "(k**2 - 8*sqrt(3)*I*k**2 - 6*sqrt(3)*k - 24*I*k - 21)/(4*k**2 + 3)"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{2 \\cdot \\left(2 k^{2} + 3 \\sqrt{k^{2} + 1}\\right)}{4 k^{2} + 3} + \\frac{i \\left(6 k \\sqrt{k^{2} + 1} - 3 k - \\sqrt{3} \\cdot \\left(4 k^{2} + 3\\right)\\right)}{4 k^{2} + 3}$"
      ],
      "text/plain": [
       "2*(2*k**2 + 3*sqrt(k**2 + 1))/(4*k**2 + 3) + I*(6*k*sqrt(k**2 + 1) - 3*k - sqrt(3)*(4*k**2 + 3))/(4*k**2 + 3)"
      ]
     },
     "execution_count": 306,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Complex(B-C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - \\sqrt{3} i$"
      ],
      "text/plain": [
       "1 - sqrt(3)*I"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Complex(F-C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "check=Eq(re(end)/im(end),-re(Complex(F-C))/im(Complex(F-C)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{k^{2} - 6 \\sqrt{3} k - 21}{- 8 \\sqrt{3} k^{2} - 24 k} = \\frac{\\sqrt{3}}{3}$"
      ],
      "text/plain": [
       "Eq((k**2 - 6*sqrt(3)*k - 21)/(-8*sqrt(3)*k**2 - 24*k), sqrt(3)/3)"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 27 k^{2} + 6 \\sqrt{3} k - 63$"
      ],
      "text/plain": [
       "27*k**2 + 6*sqrt(3)*k - 63"
      ]
     },
     "execution_count": 323,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(simplify_equation(check,fraction=True,expr=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 \\cdot \\left(9 k^{2} + 2 \\sqrt{3} k - 21\\right)$"
      ],
      "text/plain": [
       "3*(9*k**2 + 2*sqrt(3)*k - 21)"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\sqrt{3}, \\frac{7 \\sqrt{3}}{9}\\right\\}$"
      ],
      "text/plain": [
       "{-sqrt(3), 7*sqrt(3)/9}"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(_,k,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m=Line(x-t*y-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 6 t y + y^{2} \\cdot \\left(3 t^{2} + 4\\right) - 9$"
      ],
      "text/plain": [
       "6*t*y + y**2*(3*t**2 + 4) - 9"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "line_and_quadratic(m,e,first=False,y=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q=QuadraticFunction(_,x=y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 144 t^{2} + 144$"
      ],
      "text/plain": [
       "144*t**2 + 144"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=-y**2/3-2*sqrt(3)*y+7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{y^{2}}{3} - 2 \\sqrt{3} y + 7$"
      ],
      "text/plain": [
       "-y**2/3 - 2*sqrt(3)*y + 7"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y1,y2=symbols(\"y1:3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\left(y_{1} - y_{2}\\right) \\left(2 \\sqrt{3} y_{1} y_{2} - 7 y_{1} - 7 y_{2}\\right)$"
      ],
      "text/plain": [
       "-(y1 - y2)*(2*sqrt(3)*y1*y2 - 7*y1 - 7*y2)"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(simplify(simplify_equation(Eq((y1/y2)**2,expr.subs(y,y1)/expr.subs(y,y2)),fraction=True,expr=True)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
